ui/aura/window.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/aura/window.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/callback.h"
  12 #include "base/logging.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "ui/aura/client/capture_client.h"
  17 #include "ui/aura/client/cursor_client.h"
  18 #include "ui/aura/client/event_client.h"
  19 #include "ui/aura/client/focus_client.h"
  20 #include "ui/aura/client/screen_position_client.h"
  21 #include "ui/aura/client/visibility_client.h"
  22 #include "ui/aura/client/window_stacking_client.h"
  23 #include "ui/aura/env.h"
  24 #include "ui/aura/layout_manager.h"
  25 #include "ui/aura/window_delegate.h"
  26 #include "ui/aura/window_event_dispatcher.h"
  27 #include "ui/aura/window_observer.h"
  28 #include "ui/aura/window_tracker.h"
  29 #include "ui/aura/window_tree_host.h"
  30 #include "ui/compositor/compositor.h"
  31 #include "ui/compositor/layer.h"
  32 #include "ui/events/event_target_iterator.h"
  33 #include "ui/gfx/canvas.h"
  34 #include "ui/gfx/path.h"
  35 #include "ui/gfx/scoped_canvas.h"
  36 #include "ui/gfx/screen.h"
  37
  38 namespace aura {
  39
  40 namespace {
  41
  42 ui::LayerType WindowLayerTypeToUILayerType(WindowLayerType window_layer_type) {
  43   switch (window_layer_type) {
  44     case WINDOW_LAYER_NONE:
  45       break;
  46     case WINDOW_LAYER_NOT_DRAWN:
  47       return ui::LAYER_NOT_DRAWN;
  48     case WINDOW_LAYER_TEXTURED:
  49       return ui::LAYER_TEXTURED;
  50     case WINDOW_LAYER_SOLID_COLOR:
  51       return ui::LAYER_SOLID_COLOR;
  52   }
  53   NOTREACHED();
  54   return ui::LAYER_NOT_DRAWN;
  55 }
  56
  57 // Used when searching for a Window to stack relative to.
  58 template <class T>
  59 T IteratorForDirectionBegin(aura::Window* window);
  60
  61 template <>
  62 Window::Windows::const_iterator IteratorForDirectionBegin(
  63     aura::Window* window) {
  64   return window->children().begin();
  65 }
  66
  67 template <>
  68 Window::Windows::const_reverse_iterator IteratorForDirectionBegin(
  69     aura::Window* window) {
  70   return window->children().rbegin();
  71 }
  72
  73 template <class T>
  74 T IteratorForDirectionEnd(aura::Window* window);
  75
  76 template <>
  77 Window::Windows::const_iterator IteratorForDirectionEnd(aura::Window* window) {
  78   return window->children().end();
  79 }
  80
  81 template <>
  82 Window::Windows::const_reverse_iterator IteratorForDirectionEnd(
  83     aura::Window* window) {
  84   return window->children().rend();
  85 }
  86
  87 // Depth first search for the first Window with a layer to stack relative
  88 // to. Starts at target. Does not descend into |ignore|.
  89 template <class T>
  90 ui::Layer* FindStackingTargetLayerDown(aura::Window* target,
  91                                        aura::Window* ignore) {
  92   if (target == ignore)
  93     return NULL;
  94
  95   if (target->layer())
  96     return target->layer();
  97
  98   for (T i = IteratorForDirectionBegin<T>(target);
  99        i != IteratorForDirectionEnd<T>(target); ++i) {
 100     ui::Layer* layer = FindStackingTargetLayerDown<T>(*i, ignore);
 101     if (layer)
 102       return layer;
 103   }
 104   return NULL;
 105 }
 106
 107 // Depth first search through the siblings of |target||. This does not search
 108 // all the siblings, only those before/after |target| (depening upon the
 109 // template type) and ignoring |ignore|. Returns the Layer of the first Window
 110 // encountered with a Layer.
 111 template <class T>
 112 ui::Layer* FindStackingLayerInSiblings(aura::Window* target,
 113                                        aura::Window* ignore) {
 114   aura::Window* parent = target->parent();
 115   for (T i = std::find(IteratorForDirectionBegin<T>(parent),
 116                   IteratorForDirectionEnd<T>(parent), target);
 117        i != IteratorForDirectionEnd<T>(parent); ++i) {
 118     ui::Layer* layer = FindStackingTargetLayerDown<T>(*i, ignore);
 119     if (layer)
 120       return layer;
 121   }
 122   return NULL;
 123 }
 124
 125 // Returns the first Window that has a Layer. This does a depth first search
 126 // through the descendants of |target| first, then ascends up doing a depth
 127 // first search through siblings of all ancestors until a Layer is found or an
 128 // ancestor with a layer is found. This is intended to locate a layer to stack
 129 // other layers relative to.
 130 template <class T>
 131 ui::Layer* FindStackingTargetLayer(aura::Window* target, aura::Window* ignore) {
 132   ui::Layer* result = FindStackingTargetLayerDown<T>(target, ignore);
 133   if (result)
 134     return result;
 135   while (target->parent()) {
 136     ui::Layer* result = FindStackingLayerInSiblings<T>(target, ignore);
 137     if (result)
 138       return result;
 139     target = target->parent();
 140     if (target->layer())
 141       return NULL;
 142   }
 143   return NULL;
 144 }
 145
 146 // Does a depth first search for all descendants of |child| that have layers.
 147 // This stops at any descendants that have layers (and adds them to |layers|).
 148 void GetLayersToStack(aura::Window* child, std::vector<ui::Layer*>* layers) {
 149   if (child->layer()) {
 150     layers->push_back(child->layer());
 151     return;
 152   }
 153   for (size_t i = 0; i < child->children().size(); ++i)
 154     GetLayersToStack(child->children()[i], layers);
 155 }
 156
 157 }  // namespace
 158
 159 class ScopedCursorHider {
 160  public:
 161   explicit ScopedCursorHider(Window* window)
 162       : window_(window),
 163         hid_cursor_(false) {
 164     if (!window_->IsRootWindow())
 165       return;
 166     const bool cursor_is_in_bounds = window_->GetBoundsInScreen().Contains(
 167         Env::GetInstance()->last_mouse_location());
 168     client::CursorClient* cursor_client = client::GetCursorClient(window_);
 169     if (cursor_is_in_bounds && cursor_client &&
 170         cursor_client->IsCursorVisible()) {
 171       cursor_client->HideCursor();
 172       hid_cursor_ = true;
 173     }
 174   }
 175   ~ScopedCursorHider() {
 176     if (!window_->IsRootWindow())
 177       return;
 178
 179     // Update the device scale factor of the cursor client only when the last
 180     // mouse location is on this root window.
 181     if (hid_cursor_) {
 182       client::CursorClient* cursor_client = client::GetCursorClient(window_);
 183       if (cursor_client) {
 184         const gfx::Display& display =
 185             gfx::Screen::GetScreenFor(window_)->GetDisplayNearestWindow(
 186                 window_);
 187         cursor_client->SetDisplay(display);
 188         cursor_client->ShowCursor();
 189       }
 190     }
 191   }
 192
 193  private:
 194   Window* window_;
 195   bool hid_cursor_;
 196
 197   DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
 198 };
 199
 200 Window::Window(WindowDelegate* delegate)
 201     : host_(NULL),
 202       type_(ui::wm::WINDOW_TYPE_UNKNOWN),
 203       owned_by_parent_(true),
 204       delegate_(delegate),
 205       parent_(NULL),
 206       visible_(false),
 207       id_(-1),
 208       transparent_(false),
 209       user_data_(NULL),
 210       ignore_events_(false),
 211       // Don't notify newly added observers during notification. This causes
 212       // problems for code that adds an observer as part of an observer
 213       // notification (such as the workspace code).
 214       observers_(ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
 215   set_target_handler(delegate_);
 216 }
 217
 218 Window::~Window() {
 219   // |layer()| can be NULL during tests, or if this Window is layerless.
 220   if (layer()) {
 221     if (layer()->owner() == this)
 222       layer()->CompleteAllAnimations();
 223     layer()->SuppressPaint();
 224   }
 225
 226   // Let the delegate know we're in the processing of destroying.
 227   if (delegate_)
 228     delegate_->OnWindowDestroying(this);
 229   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
 230
 231   // TODO(beng): See comment in window_event_dispatcher.h. This shouldn't be
 232   //             necessary but unfortunately is right now due to ordering
 233   //             peculiarities. WED must be notified _after_ other observers
 234   //             are notified of pending teardown but before the hierarchy
 235   //             is actually torn down.
 236   WindowTreeHost* host = GetHost();
 237   if (host)
 238     host->dispatcher()->OnPostNotifiedWindowDestroying(this);
 239
 240   // The window should have already had its state cleaned up in
 241   // WindowEventDispatcher::OnWindowHidden(), but there have been some crashes
 242   // involving windows being destroyed without being hidden first. See
 243   // crbug.com/342040. This should help us debug the issue. TODO(tdresser):
 244   // remove this once we determine why we have windows that are destroyed
 245   // without being hidden.
 246   bool window_incorrectly_cleaned_up = CleanupGestureState();
 247   CHECK(!window_incorrectly_cleaned_up);
 248
 249   // Then destroy the children.
 250   RemoveOrDestroyChildren();
 251
 252   // The window needs to be removed from the parent before calling the
 253   // WindowDestroyed callbacks of delegate and the observers.
 254   if (parent_)
 255     parent_->RemoveChild(this);
 256
 257   if (delegate_)
 258     delegate_->OnWindowDestroyed(this);
 259   ObserverListBase<WindowObserver>::Iterator iter(observers_);
 260   for (WindowObserver* observer = iter.GetNext(); observer;
 261        observer = iter.GetNext()) {
 262     RemoveObserver(observer);
 263     observer->OnWindowDestroyed(this);
 264   }
 265
 266   // Clear properties.
 267   for (std::map<const void*, Value>::const_iterator iter = prop_map_.begin();
 268        iter != prop_map_.end();
 269        ++iter) {
 270     if (iter->second.deallocator)
 271       (*iter->second.deallocator)(iter->second.value);
 272   }
 273   prop_map_.clear();
 274
 275   // If we have layer it will either be destroyed by |layer_owner_|'s dtor, or
 276   // by whoever acquired it. We don't have a layer if Init() wasn't invoked or
 277   // we are layerless.
 278   if (layer())
 279     layer()->set_delegate(NULL);
 280   DestroyLayer();
 281 }
 282
 283 void Window::Init(WindowLayerType window_layer_type) {
 284   if (window_layer_type != WINDOW_LAYER_NONE) {
 285     SetLayer(new ui::Layer(WindowLayerTypeToUILayerType(window_layer_type)));
 286     layer()->SetVisible(false);
 287     layer()->set_delegate(this);
 288     UpdateLayerName();
 289     layer()->SetFillsBoundsOpaquely(!transparent_);
 290   }
 291
 292   Env::GetInstance()->NotifyWindowInitialized(this);
 293 }
 294
 295 void Window::SetType(ui::wm::WindowType type) {
 296   // Cannot change type after the window is initialized.
 297   DCHECK(!layer());
 298   type_ = type;
 299 }
 300
 301 void Window::SetName(const std::string& name) {
 302   name_ = name;
 303
 304   if (layer())
 305     UpdateLayerName();
 306 }
 307
 308 void Window::SetTitle(const base::string16& title) {
 309   title_ = title;
 310   FOR_EACH_OBSERVER(WindowObserver,
 311                     observers_,
 312                     OnWindowTitleChanged(this));
 313 }
 314
 315 void Window::SetTransparent(bool transparent) {
 316   transparent_ = transparent;
 317   if (layer())
 318     layer()->SetFillsBoundsOpaquely(!transparent_);
 319 }
 320
 321 void Window::SetFillsBoundsCompletely(bool fills_bounds) {
 322   if (layer())
 323     layer()->SetFillsBoundsCompletely(fills_bounds);
 324 }
 325
 326 Window* Window::GetRootWindow() {
 327   return const_cast<Window*>(
 328       static_cast<const Window*>(this)->GetRootWindow());
 329 }
 330
 331 const Window* Window::GetRootWindow() const {
 332   return IsRootWindow() ? this : parent_ ? parent_->GetRootWindow() : NULL;
 333 }
 334
 335 WindowTreeHost* Window::GetHost() {
 336   return const_cast<WindowTreeHost*>(const_cast<const Window*>(this)->
 337       GetHost());
 338 }
 339
 340 const WindowTreeHost* Window::GetHost() const {
 341   const Window* root_window = GetRootWindow();
 342   return root_window ? root_window->host_ : NULL;
 343 }
 344
 345 void Window::Show() {
 346   if (layer()) {
 347     DCHECK_EQ(visible_, layer()->GetTargetVisibility());
 348     // It is not allowed that a window is visible but the layers alpha is fully
 349     // transparent since the window would still be considered to be active but
 350     // could not be seen.
 351     DCHECK(!(visible_ && layer()->GetTargetOpacity() == 0.0f));
 352   }
 353   SetVisible(true);
 354 }
 355
 356 void Window::Hide() {
 357   // RootWindow::OnVisibilityChanged will call ReleaseCapture.
 358   SetVisible(false);
 359 }
 360
 361 bool Window::IsVisible() const {
 362   // Layer visibility can be inconsistent with window visibility, for example
 363   // when a Window is hidden, we want this function to return false immediately
 364   // after, even though the client may decide to animate the hide effect (and
 365   // so the layer will be visible for some time after Hide() is called).
 366   for (const Window* window = this; window; window = window->parent()) {
 367     if (!window->visible_)
 368       return false;
 369     if (window->layer())
 370       return window->layer()->IsDrawn();
 371   }
 372   return false;
 373 }
 374
 375 gfx::Rect Window::GetBoundsInRootWindow() const {
 376   // TODO(beng): There may be a better way to handle this, and the existing code
 377   //             is likely wrong anyway in a multi-display world, but this will
 378   //             do for now.
 379   if (!GetRootWindow())
 380     return bounds();
 381   gfx::Point origin = bounds().origin();
 382   ConvertPointToTarget(parent_, GetRootWindow(), &origin);
 383   return gfx::Rect(origin, bounds().size());
 384 }
 385
 386 gfx::Rect Window::GetBoundsInScreen() const {
 387   gfx::Rect bounds(GetBoundsInRootWindow());
 388   const Window* root = GetRootWindow();
 389   if (root) {
 390     aura::client::ScreenPositionClient* screen_position_client =
 391         aura::client::GetScreenPositionClient(root);
 392     if (screen_position_client) {
 393       gfx::Point origin = bounds.origin();
 394       screen_position_client->ConvertPointToScreen(root, &origin);
 395       bounds.set_origin(origin);
 396     }
 397   }
 398   return bounds;
 399 }
 400
 401 void Window::SetTransform(const gfx::Transform& transform) {
 402   if (!layer()) {
 403     // Transforms aren't supported on layerless windows.
 404     NOTREACHED();
 405     return;
 406   }
 407   FOR_EACH_OBSERVER(WindowObserver, observers_,
 408                     OnWindowTransforming(this));
 409   layer()->SetTransform(transform);
 410   FOR_EACH_OBSERVER(WindowObserver, observers_,
 411                     OnWindowTransformed(this));
 412   NotifyAncestorWindowTransformed(this);
 413 }
 414
 415 void Window::SetLayoutManager(LayoutManager* layout_manager) {
 416   if (layout_manager == layout_manager_)
 417     return;
 418   layout_manager_.reset(layout_manager);
 419   if (!layout_manager)
 420     return;
 421   // If we're changing to a new layout manager, ensure it is aware of all the
 422   // existing child windows.
 423   for (Windows::const_iterator it = children_.begin();
 424        it != children_.end();
 425        ++it)
 426     layout_manager_->OnWindowAddedToLayout(*it);
 427 }
 428
 429 scoped_ptr<ui::EventTargeter>
 430 Window::SetEventTargeter(scoped_ptr<ui::EventTargeter> targeter) {
 431   scoped_ptr<ui::EventTargeter> old_targeter = targeter_.Pass();
 432   targeter_ = targeter.Pass();
 433   return old_targeter.Pass();
 434 }
 435
 436 void Window::SetBounds(const gfx::Rect& new_bounds) {
 437   if (parent_ && parent_->layout_manager())
 438     parent_->layout_manager()->SetChildBounds(this, new_bounds);
 439   else {
 440     // Ensure we don't go smaller than our minimum bounds.
 441     gfx::Rect final_bounds(new_bounds);
 442     if (delegate_) {
 443       const gfx::Size& min_size = delegate_->GetMinimumSize();
 444       final_bounds.set_width(std::max(min_size.width(), final_bounds.width()));
 445       final_bounds.set_height(std::max(min_size.height(),
 446                                        final_bounds.height()));
 447     }
 448     SetBoundsInternal(final_bounds);
 449   }
 450 }
 451
 452 void Window::SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen,
 453                                const gfx::Display& dst_display) {
 454   Window* root = GetRootWindow();
 455   if (root) {
 456     gfx::Point origin = new_bounds_in_screen.origin();
 457     aura::client::ScreenPositionClient* screen_position_client =
 458         aura::client::GetScreenPositionClient(root);
 459     screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
 460     return;
 461   }
 462   SetBounds(new_bounds_in_screen);
 463 }
 464
 465 gfx::Rect Window::GetTargetBounds() const {
 466   if (!layer())
 467     return bounds();
 468
 469   if (!parent_ || parent_->layer())
 470     return layer()->GetTargetBounds();
 471
 472   // We have a layer but our parent (who is valid) doesn't. This means the
 473   // coordinates of the layer are relative to the first ancestor with a layer;
 474   // convert to be relative to parent.
 475   gfx::Vector2d offset;
 476   const aura::Window* ancestor_with_layer =
 477       parent_->GetAncestorWithLayer(&offset);
 478   if (!ancestor_with_layer)
 479     return layer()->GetTargetBounds();
 480
 481   gfx::Rect layer_target_bounds = layer()->GetTargetBounds();
 482   layer_target_bounds -= offset;
 483   return layer_target_bounds;
 484 }
 485
 486 void Window::SchedulePaintInRect(const gfx::Rect& rect) {
 487   if (!layer() && parent_) {
 488     // Notification of paint scheduled happens for the window with a layer.
 489     gfx::Rect parent_rect(bounds().size());
 490     parent_rect.Intersect(rect);
 491     if (!parent_rect.IsEmpty()) {
 492       parent_rect.Offset(bounds().origin().OffsetFromOrigin());
 493       parent_->SchedulePaintInRect(parent_rect);
 494     }
 495   } else if (layer()) {
 496     layer()->SchedulePaint(rect);
 497   }
 498 }
 499
 500 void Window::StackChildAtTop(Window* child) {
 501   if (children_.size() <= 1 || child == children_.back())
 502     return;  // In the front already.
 503   StackChildAbove(child, children_.back());
 504 }
 505
 506 void Window::StackChildAbove(Window* child, Window* target) {
 507   StackChildRelativeTo(child, target, STACK_ABOVE);
 508 }
 509
 510 void Window::StackChildAtBottom(Window* child) {
 511   if (children_.size() <= 1 || child == children_.front())
 512     return;  // At the bottom already.
 513   StackChildBelow(child, children_.front());
 514 }
 515
 516 void Window::StackChildBelow(Window* child, Window* target) {
 517   StackChildRelativeTo(child, target, STACK_BELOW);
 518 }
 519
 520 void Window::AddChild(Window* child) {
 521   WindowObserver::HierarchyChangeParams params;
 522   params.target = child;
 523   params.new_parent = this;
 524   params.old_parent = child->parent();
 525   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
 526   NotifyWindowHierarchyChange(params);
 527
 528   Window* old_root = child->GetRootWindow();
 529
 530   DCHECK(std::find(children_.begin(), children_.end(), child) ==
 531       children_.end());
 532   if (child->parent())
 533     child->parent()->RemoveChildImpl(child, this);
 534
 535   gfx::Vector2d offset;
 536   aura::Window* ancestor_with_layer = GetAncestorWithLayer(&offset);
 537
 538   child->parent_ = this;
 539
 540   if (ancestor_with_layer) {
 541     offset += child->bounds().OffsetFromOrigin();
 542     child->ReparentLayers(ancestor_with_layer->layer(), offset);
 543   }
 544
 545   children_.push_back(child);
 546   if (layout_manager_)
 547     layout_manager_->OnWindowAddedToLayout(child);
 548   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
 549   child->OnParentChanged();
 550
 551   Window* root_window = GetRootWindow();
 552   if (root_window && old_root != root_window) {
 553     root_window->GetHost()->dispatcher()->OnWindowAddedToRootWindow(child);
 554     child->NotifyAddedToRootWindow();
 555   }
 556
 557   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
 558   NotifyWindowHierarchyChange(params);
 559 }
 560
 561 void Window::RemoveChild(Window* child) {
 562   WindowObserver::HierarchyChangeParams params;
 563   params.target = child;
 564   params.new_parent = NULL;
 565   params.old_parent = this;
 566   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
 567   NotifyWindowHierarchyChange(params);
 568
 569   RemoveChildImpl(child, NULL);
 570
 571   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
 572   NotifyWindowHierarchyChange(params);
 573 }
 574
 575 bool Window::Contains(const Window* other) const {
 576   for (const Window* parent = other; parent; parent = parent->parent_) {
 577     if (parent == this)
 578       return true;
 579   }
 580   return false;
 581 }
 582
 583 Window* Window::GetChildById(int id) {
 584   return const_cast<Window*>(const_cast<const Window*>(this)->GetChildById(id));
 585 }
 586
 587 const Window* Window::GetChildById(int id) const {
 588   Windows::const_iterator i;
 589   for (i = children_.begin(); i != children_.end(); ++i) {
 590     if ((*i)->id() == id)
 591       return *i;
 592     const Window* result = (*i)->GetChildById(id);
 593     if (result)
 594       return result;
 595   }
 596   return NULL;
 597 }
 598
 599 // static
 600 void Window::ConvertPointToTarget(const Window* source,
 601                                   const Window* target,
 602                                   gfx::Point* point) {
 603   if (!source)
 604     return;
 605   if (source->GetRootWindow() != target->GetRootWindow()) {
 606     client::ScreenPositionClient* source_client =
 607         client::GetScreenPositionClient(source->GetRootWindow());
 608     // |source_client| can be NULL in tests.
 609     if (source_client)
 610       source_client->ConvertPointToScreen(source, point);
 611
 612     client::ScreenPositionClient* target_client =
 613         client::GetScreenPositionClient(target->GetRootWindow());
 614     // |target_client| can be NULL in tests.
 615     if (target_client)
 616       target_client->ConvertPointFromScreen(target, point);
 617   } else if ((source != target) && (!source->layer() || !target->layer())) {
 618     if (!source->layer()) {
 619       gfx::Vector2d offset_to_layer;
 620       source = source->GetAncestorWithLayer(&offset_to_layer);
 621       *point += offset_to_layer;
 622     }
 623     if (!target->layer()) {
 624       gfx::Vector2d offset_to_layer;
 625       target = target->GetAncestorWithLayer(&offset_to_layer);
 626       *point -= offset_to_layer;
 627     }
 628     ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
 629   } else {
 630     ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
 631   }
 632 }
 633
 634 // static
 635 void Window::ConvertRectToTarget(const Window* source,
 636                                  const Window* target,
 637                                  gfx::Rect* rect) {
 638   DCHECK(rect);
 639   gfx::Point origin = rect->origin();
 640   ConvertPointToTarget(source, target, &origin);
 641   rect->set_origin(origin);
 642 }
 643
 644 void Window::MoveCursorTo(const gfx::Point& point_in_window) {
 645   Window* root_window = GetRootWindow();
 646   DCHECK(root_window);
 647   gfx::Point point_in_root(point_in_window);
 648   ConvertPointToTarget(this, root_window, &point_in_root);
 649   root_window->GetHost()->MoveCursorTo(point_in_root);
 650 }
 651
 652 gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
 653   return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
 654 }
 655
 656 void Window::AddObserver(WindowObserver* observer) {
 657   observer->OnObservingWindow(this);
 658   observers_.AddObserver(observer);
 659 }
 660
 661 void Window::RemoveObserver(WindowObserver* observer) {
 662   observer->OnUnobservingWindow(this);
 663   observers_.RemoveObserver(observer);
 664 }
 665
 666 bool Window::HasObserver(WindowObserver* observer) {
 667   return observers_.HasObserver(observer);
 668 }
 669
 670 bool Window::ContainsPointInRoot(const gfx::Point& point_in_root) const {
 671   const Window* root_window = GetRootWindow();
 672   if (!root_window)
 673     return false;
 674   gfx::Point local_point(point_in_root);
 675   ConvertPointToTarget(root_window, this, &local_point);
 676   return gfx::Rect(GetTargetBounds().size()).Contains(local_point);
 677 }
 678
 679 bool Window::ContainsPoint(const gfx::Point& local_point) const {
 680   return gfx::Rect(bounds().size()).Contains(local_point);
 681 }
 682
 683 Window* Window::GetEventHandlerForPoint(const gfx::Point& local_point) {
 684   return GetWindowForPoint(local_point, true, true);
 685 }
 686
 687 Window* Window::GetTopWindowContainingPoint(const gfx::Point& local_point) {
 688   return GetWindowForPoint(local_point, false, false);
 689 }
 690
 691 Window* Window::GetToplevelWindow() {
 692   Window* topmost_window_with_delegate = NULL;
 693   for (aura::Window* window = this; window != NULL; window = window->parent()) {
 694     if (window->delegate())
 695       topmost_window_with_delegate = window;
 696   }
 697   return topmost_window_with_delegate;
 698 }
 699
 700 void Window::Focus() {
 701   client::FocusClient* client = client::GetFocusClient(this);
 702   DCHECK(client);
 703   client->FocusWindow(this);
 704 }
 705
 706 void Window::Blur() {
 707   client::FocusClient* client = client::GetFocusClient(this);
 708   DCHECK(client);
 709   client->FocusWindow(NULL);
 710 }
 711
 712 bool Window::HasFocus() const {
 713   client::FocusClient* client = client::GetFocusClient(this);
 714   return client && client->GetFocusedWindow() == this;
 715 }
 716
 717 bool Window::CanFocus() const {
 718   if (IsRootWindow())
 719     return IsVisible();
 720
 721   // NOTE: as part of focusing the window the ActivationClient may make the
 722   // window visible (by way of making a hidden ancestor visible). For this
 723   // reason we can't check visibility here and assume the client is doing it.
 724   if (!parent_ || (delegate_ && !delegate_->CanFocus()))
 725     return false;
 726
 727   // The client may forbid certain windows from receiving focus at a given point
 728   // in time.
 729   client::EventClient* client = client::GetEventClient(GetRootWindow());
 730   if (client && !client->CanProcessEventsWithinSubtree(this))
 731     return false;
 732
 733   return parent_->CanFocus();
 734 }
 735
 736 bool Window::CanReceiveEvents() const {
 737   if (IsRootWindow())
 738     return IsVisible();
 739
 740   // The client may forbid certain windows from receiving events at a given
 741   // point in time.
 742   client::EventClient* client = client::GetEventClient(GetRootWindow());
 743   if (client && !client->CanProcessEventsWithinSubtree(this))
 744     return false;
 745
 746   return parent_ && IsVisible() && parent_->CanReceiveEvents();
 747 }
 748
 749 void Window::SetCapture() {
 750   if (!IsVisible())
 751     return;
 752
 753   Window* root_window = GetRootWindow();
 754   if (!root_window)
 755     return;
 756   client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
 757   if (!capture_client)
 758     return;
 759   client::GetCaptureClient(root_window)->SetCapture(this);
 760 }
 761
 762 void Window::ReleaseCapture() {
 763   Window* root_window = GetRootWindow();
 764   if (!root_window)
 765     return;
 766   client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
 767   if (!capture_client)
 768     return;
 769   client::GetCaptureClient(root_window)->ReleaseCapture(this);
 770 }
 771
 772 bool Window::HasCapture() {
 773   Window* root_window = GetRootWindow();
 774   if (!root_window)
 775     return false;
 776   client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
 777   return capture_client && capture_client->GetCaptureWindow() == this;
 778 }
 779
 780 void Window::SuppressPaint() {
 781   if (layer())
 782     layer()->SuppressPaint();
 783 }
 784
 785 // {Set,Get,Clear}Property are implemented in window_property.h.
 786
 787 void Window::SetNativeWindowProperty(const char* key, void* value) {
 788   SetPropertyInternal(
 789       key, key, NULL, reinterpret_cast<int64>(value), 0);
 790 }
 791
 792 void* Window::GetNativeWindowProperty(const char* key) const {
 793   return reinterpret_cast<void*>(GetPropertyInternal(key, 0));
 794 }
 795
 796 void Window::OnDeviceScaleFactorChanged(float device_scale_factor) {
 797   ScopedCursorHider hider(this);
 798   if (delegate_)
 799     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
 800 }
 801
 802 #if !defined(NDEBUG)
 803 std::string Window::GetDebugInfo() const {
 804   return base::StringPrintf(
 805       "%s<%d> bounds(%d, %d, %d, %d) %s %s opacity=%.1f",
 806       name().empty() ? "Unknown" : name().c_str(), id(),
 807       bounds().x(), bounds().y(), bounds().width(), bounds().height(),
 808       visible_ ? "WindowVisible" : "WindowHidden",
 809       layer() ?
 810           (layer()->GetTargetVisibility() ? "LayerVisible" : "LayerHidden") :
 811           "NoLayer",
 812       layer() ? layer()->opacity() : 1.0f);
 813 }
 814
 815 void Window::PrintWindowHierarchy(int depth) const {
 816   VLOG(0) << base::StringPrintf(
 817       "%*s%s", depth * 2, "", GetDebugInfo().c_str());
 818   for (Windows::const_iterator it = children_.begin();
 819        it != children_.end(); ++it) {
 820     Window* child = *it;
 821     child->PrintWindowHierarchy(depth + 1);
 822   }
 823 }
 824 #endif
 825
 826 void Window::RemoveOrDestroyChildren() {
 827   while (!children_.empty()) {
 828     Window* child = children_[0];
 829     if (child->owned_by_parent_) {
 830       delete child;
 831       // Deleting the child so remove it from out children_ list.
 832       DCHECK(std::find(children_.begin(), children_.end(), child) ==
 833              children_.end());
 834     } else {
 835       // Even if we can't delete the child, we still need to remove it from the
 836       // parent so that relevant bookkeeping (parent_ back-pointers etc) are
 837       // updated.
 838       RemoveChild(child);
 839     }
 840   }
 841 }
 842
 843 ///////////////////////////////////////////////////////////////////////////////
 844 // Window, private:
 845
 846 int64 Window::SetPropertyInternal(const void* key,
 847                                   const char* name,
 848                                   PropertyDeallocator deallocator,
 849                                   int64 value,
 850                                   int64 default_value) {
 851   int64 old = GetPropertyInternal(key, default_value);
 852   if (value == default_value) {
 853     prop_map_.erase(key);
 854   } else {
 855     Value prop_value;
 856     prop_value.name = name;
 857     prop_value.value = value;
 858     prop_value.deallocator = deallocator;
 859     prop_map_[key] = prop_value;
 860   }
 861   FOR_EACH_OBSERVER(WindowObserver, observers_,
 862                     OnWindowPropertyChanged(this, key, old));
 863   return old;
 864 }
 865
 866 int64 Window::GetPropertyInternal(const void* key,
 867                                   int64 default_value) const {
 868   std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
 869   if (iter == prop_map_.end())
 870     return default_value;
 871   return iter->second.value;
 872 }
 873
 874 bool Window::HitTest(const gfx::Point& local_point) {
 875   gfx::Rect local_bounds(bounds().size());
 876   if (!delegate_ || !delegate_->HasHitTestMask())
 877     return local_bounds.Contains(local_point);
 878
 879   gfx::Path mask;
 880   delegate_->GetHitTestMask(&mask);
 881
 882   SkRegion clip_region;
 883   clip_region.setRect(local_bounds.x(), local_bounds.y(),
 884                       local_bounds.width(), local_bounds.height());
 885   SkRegion mask_region;
 886   return mask_region.setPath(mask, clip_region) &&
 887       mask_region.contains(local_point.x(), local_point.y());
 888 }
 889
 890 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
 891   gfx::Rect actual_new_bounds(new_bounds);
 892   gfx::Rect old_bounds = GetTargetBounds();
 893
 894   // Always need to set the layer's bounds -- even if it is to the same thing.
 895   // This may cause important side effects such as stopping animation.
 896   if (!layer()) {
 897     const gfx::Vector2d origin_delta = new_bounds.OffsetFromOrigin() -
 898         bounds_.OffsetFromOrigin();
 899     bounds_ = new_bounds;
 900     OffsetLayerBounds(origin_delta);
 901   } else {
 902     if (parent_ && !parent_->layer()) {
 903       gfx::Vector2d offset;
 904       const aura::Window* ancestor_with_layer =
 905           parent_->GetAncestorWithLayer(&offset);
 906       if (ancestor_with_layer)
 907         actual_new_bounds.Offset(offset);
 908     }
 909     layer()->SetBounds(actual_new_bounds);
 910   }
 911
 912   // If we are currently not the layer's delegate, we will not get bounds
 913   // changed notification from the layer (this typically happens after animating
 914   // hidden). We must notify ourselves.
 915   if (!layer() || layer()->delegate() != this)
 916     OnWindowBoundsChanged(old_bounds);
 917 }
 918
 919 void Window::SetVisible(bool visible) {
 920   if ((layer() && visible == layer()->GetTargetVisibility()) ||
 921       (!layer() && visible == visible_))
 922     return;  // No change.
 923
 924   FOR_EACH_OBSERVER(WindowObserver, observers_,
 925                     OnWindowVisibilityChanging(this, visible));
 926
 927   client::VisibilityClient* visibility_client =
 928       client::GetVisibilityClient(this);
 929   if (visibility_client)
 930     visibility_client->UpdateLayerVisibility(this, visible);
 931   else if (layer())
 932     layer()->SetVisible(visible);
 933   visible_ = visible;
 934   SchedulePaint();
 935   if (parent_ && parent_->layout_manager_)
 936     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
 937
 938   if (delegate_)
 939     delegate_->OnWindowTargetVisibilityChanged(visible);
 940
 941   NotifyWindowVisibilityChanged(this, visible);
 942 }
 943
 944 void Window::SchedulePaint() {
 945   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 946 }
 947
 948 void Window::Paint(gfx::Canvas* canvas) {
 949   if (delegate_)
 950     delegate_->OnPaint(canvas);
 951   PaintLayerlessChildren(canvas);
 952 }
 953
 954 void Window::PaintLayerlessChildren(gfx::Canvas* canvas) {
 955   for (size_t i = 0, count = children_.size(); i < count; ++i) {
 956     Window* child = children_[i];
 957     if (!child->layer() && child->visible_) {
 958       gfx::ScopedCanvas scoped_canvas(canvas);
 959       canvas->ClipRect(child->bounds());
 960       if (!canvas->IsClipEmpty()) {
 961         canvas->Translate(child->bounds().OffsetFromOrigin());
 962         child->Paint(canvas);
 963       }
 964     }
 965   }
 966 }
 967
 968 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
 969                                   bool return_tightest,
 970                                   bool for_event_handling) {
 971   if (!IsVisible())
 972     return NULL;
 973
 974   if ((for_event_handling && !HitTest(local_point)) ||
 975       (!for_event_handling && !ContainsPoint(local_point)))
 976     return NULL;
 977
 978   // Check if I should claim this event and not pass it to my children because
 979   // the location is inside my hit test override area.  For details, see
 980   // set_hit_test_bounds_override_inner().
 981   if (for_event_handling && !hit_test_bounds_override_inner_.empty()) {
 982     gfx::Rect inset_local_bounds(gfx::Point(), bounds().size());
 983     inset_local_bounds.Inset(hit_test_bounds_override_inner_);
 984     // We know we're inside the normal local bounds, so if we're outside the
 985     // inset bounds we must be in the special hit test override area.
 986     DCHECK(HitTest(local_point));
 987     if (!inset_local_bounds.Contains(local_point))
 988       return delegate_ ? this : NULL;
 989   }
 990
 991   if (!return_tightest && delegate_)
 992     return this;
 993
 994   for (Windows::const_reverse_iterator it = children_.rbegin(),
 995            rend = children_.rend();
 996        it != rend; ++it) {
 997     Window* child = *it;
 998
 999     if (for_event_handling) {
1000       if (child->ignore_events_)
1001         continue;
1002       // The client may not allow events to be processed by certain subtrees.
1003       client::EventClient* client = client::GetEventClient(GetRootWindow());
1004       if (client && !client->CanProcessEventsWithinSubtree(child))
1005         continue;
1006       if (delegate_ && !delegate_->ShouldDescendIntoChildForEventHandling(
1007               child, local_point))
1008         continue;
1009     }
1010
1011     gfx::Point point_in_child_coords(local_point);
1012     ConvertPointToTarget(this, child, &point_in_child_coords);
1013     Window* match = child->GetWindowForPoint(point_in_child_coords,
1014                                              return_tightest,
1015                                              for_event_handling);
1016     if (match)
1017       return match;
1018   }
1019
1020   return delegate_ ? this : NULL;
1021 }
1022
1023 void Window::RemoveChildImpl(Window* child, Window* new_parent) {
1024   if (layout_manager_)
1025     layout_manager_->OnWillRemoveWindowFromLayout(child);
1026   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
1027   Window* root_window = child->GetRootWindow();
1028   Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
1029   if (root_window && root_window != new_root_window)
1030     child->NotifyRemovingFromRootWindow(new_root_window);
1031
1032   gfx::Vector2d offset;
1033   GetAncestorWithLayer(&offset);
1034   child->UnparentLayers(!layer(), offset);
1035   child->parent_ = NULL;
1036   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
1037   DCHECK(i != children_.end());
1038   children_.erase(i);
1039   child->OnParentChanged();
1040   if (layout_manager_)
1041     layout_manager_->OnWindowRemovedFromLayout(child);
1042 }
1043
1044 void Window::UnparentLayers(bool has_layerless_ancestor,
1045                             const gfx::Vector2d& offset) {
1046   if (!layer()) {
1047     const gfx::Vector2d new_offset = offset + bounds().OffsetFromOrigin();
1048     for (size_t i = 0; i < children_.size(); ++i) {
1049       children_[i]->UnparentLayers(true, new_offset);
1050     }
1051   } else {
1052     // Only remove the layer if we still own it.  Someone else may have acquired
1053     // ownership of it via AcquireLayer() and may expect the hierarchy to go
1054     // unchanged as the Window is destroyed.
1055     if (OwnsLayer()) {
1056       if (layer()->parent())
1057         layer()->parent()->Remove(layer());
1058       if (has_layerless_ancestor) {
1059         const gfx::Rect real_bounds(bounds_);
1060         gfx::Rect layer_bounds(layer()->bounds());
1061         layer_bounds.Offset(-offset);
1062         layer()->SetBounds(layer_bounds);
1063         bounds_ = real_bounds;
1064       }
1065     }
1066   }
1067 }
1068
1069 void Window::ReparentLayers(ui::Layer* parent_layer,
1070                             const gfx::Vector2d& offset) {
1071   if (!layer()) {
1072     for (size_t i = 0; i < children_.size(); ++i) {
1073       children_[i]->ReparentLayers(
1074           parent_layer,
1075           offset + children_[i]->bounds().OffsetFromOrigin());
1076     }
1077   } else {
1078     const gfx::Rect real_bounds(bounds());
1079     parent_layer->Add(layer());
1080     gfx::Rect layer_bounds(layer()->bounds().size());
1081     layer_bounds += offset;
1082     layer()->SetBounds(layer_bounds);
1083     bounds_ = real_bounds;
1084   }
1085 }
1086
1087 void Window::OffsetLayerBounds(const gfx::Vector2d& offset) {
1088   if (!layer()) {
1089     for (size_t i = 0; i < children_.size(); ++i)
1090       children_[i]->OffsetLayerBounds(offset);
1091   } else {
1092     gfx::Rect layer_bounds(layer()->bounds());
1093     layer_bounds += offset;
1094     layer()->SetBounds(layer_bounds);
1095   }
1096 }
1097
1098 void Window::OnParentChanged() {
1099   FOR_EACH_OBSERVER(
1100       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
1101 }
1102
1103 void Window::StackChildRelativeTo(Window* child,
1104                                   Window* target,
1105                                   StackDirection direction) {
1106   DCHECK_NE(child, target);
1107   DCHECK(child);
1108   DCHECK(target);
1109   DCHECK_EQ(this, child->parent());
1110   DCHECK_EQ(this, target->parent());
1111
1112   client::WindowStackingClient* stacking_client =
1113       client::GetWindowStackingClient();
1114   if (stacking_client &&
1115       !stacking_client->AdjustStacking(&child, &target, &direction))
1116     return;
1117
1118   const size_t child_i =
1119       std::find(children_.begin(), children_.end(), child) - children_.begin();
1120   const size_t target_i =
1121       std::find(children_.begin(), children_.end(), target) - children_.begin();
1122
1123   // Don't move the child if it is already in the right place.
1124   if ((direction == STACK_ABOVE && child_i == target_i + 1) ||
1125       (direction == STACK_BELOW && child_i + 1 == target_i))
1126     return;
1127
1128   const size_t dest_i =
1129       direction == STACK_ABOVE ?
1130       (child_i < target_i ? target_i : target_i + 1) :
1131       (child_i < target_i ? target_i - 1 : target_i);
1132   children_.erase(children_.begin() + child_i);
1133   children_.insert(children_.begin() + dest_i, child);
1134
1135   StackChildLayerRelativeTo(child, target, direction);
1136
1137   child->OnStackingChanged();
1138 }
1139
1140 void Window::StackChildLayerRelativeTo(Window* child,
1141                                        Window* target,
1142                                        StackDirection direction) {
1143   Window* ancestor_with_layer = GetAncestorWithLayer(NULL);
1144   ui::Layer* ancestor_layer =
1145       ancestor_with_layer ? ancestor_with_layer->layer() : NULL;
1146   if (!ancestor_layer)
1147     return;
1148
1149   if (child->layer() && target->layer()) {
1150     if (direction == STACK_ABOVE)
1151       ancestor_layer->StackAbove(child->layer(), target->layer());
1152     else
1153       ancestor_layer->StackBelow(child->layer(), target->layer());
1154     return;
1155   }
1156   typedef std::vector<ui::Layer*> Layers;
1157   Layers layers;
1158   GetLayersToStack(child, &layers);
1159   if (layers.empty())
1160     return;
1161
1162   ui::Layer* target_layer;
1163   if (direction == STACK_ABOVE) {
1164     target_layer =
1165         FindStackingTargetLayer<Windows::const_reverse_iterator>(target, child);
1166   } else {
1167     target_layer =
1168         FindStackingTargetLayer<Windows::const_iterator>(target, child);
1169   }
1170
1171   if (!target_layer) {
1172     if (direction == STACK_ABOVE) {
1173       for (Layers::const_reverse_iterator i = layers.rbegin(),
1174                rend = layers.rend(); i != rend; ++i) {
1175         ancestor_layer->StackAtBottom(*i);
1176       }
1177     } else {
1178       for (Layers::const_iterator i = layers.begin(); i != layers.end(); ++i)
1179         ancestor_layer->StackAtTop(*i);
1180     }
1181     return;
1182   }
1183
1184   if (direction == STACK_ABOVE) {
1185     for (Layers::const_reverse_iterator i = layers.rbegin(),
1186              rend = layers.rend(); i != rend; ++i) {
1187       ancestor_layer->StackAbove(*i, target_layer);
1188     }
1189   } else {
1190     for (Layers::const_iterator i = layers.begin(); i != layers.end(); ++i)
1191       ancestor_layer->StackBelow(*i, target_layer);
1192   }
1193 }
1194
1195 void Window::OnStackingChanged() {
1196   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowStackingChanged(this));
1197 }
1198
1199 void Window::NotifyRemovingFromRootWindow(Window* new_root) {
1200   FOR_EACH_OBSERVER(WindowObserver, observers_,
1201                     OnWindowRemovingFromRootWindow(this, new_root));
1202   for (Window::Windows::const_iterator it = children_.begin();
1203        it != children_.end(); ++it) {
1204     (*it)->NotifyRemovingFromRootWindow(new_root);
1205   }
1206 }
1207
1208 void Window::NotifyAddedToRootWindow() {
1209   FOR_EACH_OBSERVER(WindowObserver, observers_,
1210                     OnWindowAddedToRootWindow(this));
1211   for (Window::Windows::const_iterator it = children_.begin();
1212        it != children_.end(); ++it) {
1213     (*it)->NotifyAddedToRootWindow();
1214   }
1215 }
1216
1217 void Window::NotifyWindowHierarchyChange(
1218     const WindowObserver::HierarchyChangeParams& params) {
1219   params.target->NotifyWindowHierarchyChangeDown(params);
1220   switch (params.phase) {
1221   case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING:
1222     if (params.old_parent)
1223       params.old_parent->NotifyWindowHierarchyChangeUp(params);
1224     break;
1225   case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED:
1226     if (params.new_parent)
1227       params.new_parent->NotifyWindowHierarchyChangeUp(params);
1228     break;
1229   default:
1230     NOTREACHED();
1231     break;
1232   }
1233 }
1234
1235 void Window::NotifyWindowHierarchyChangeDown(
1236     const WindowObserver::HierarchyChangeParams& params) {
1237   NotifyWindowHierarchyChangeAtReceiver(params);
1238   for (Window::Windows::const_iterator it = children_.begin();
1239        it != children_.end(); ++it) {
1240     (*it)->NotifyWindowHierarchyChangeDown(params);
1241   }
1242 }
1243
1244 void Window::NotifyWindowHierarchyChangeUp(
1245     const WindowObserver::HierarchyChangeParams& params) {
1246   for (Window* window = this; window; window = window->parent())
1247     window->NotifyWindowHierarchyChangeAtReceiver(params);
1248 }
1249
1250 void Window::NotifyWindowHierarchyChangeAtReceiver(
1251     const WindowObserver::HierarchyChangeParams& params) {
1252   WindowObserver::HierarchyChangeParams local_params = params;
1253   local_params.receiver = this;
1254
1255   switch (params.phase) {
1256   case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING:
1257     FOR_EACH_OBSERVER(WindowObserver, observers_,
1258                       OnWindowHierarchyChanging(local_params));
1259     break;
1260   case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED:
1261     FOR_EACH_OBSERVER(WindowObserver, observers_,
1262                       OnWindowHierarchyChanged(local_params));
1263     break;
1264   default:
1265     NOTREACHED();
1266     break;
1267   }
1268 }
1269
1270 void Window::NotifyWindowVisibilityChanged(aura::Window* target,
1271                                            bool visible) {
1272   if (!NotifyWindowVisibilityChangedDown(target, visible)) {
1273     return; // |this| has been deleted.
1274   }
1275   NotifyWindowVisibilityChangedUp(target, visible);
1276 }
1277
1278 bool Window::NotifyWindowVisibilityChangedAtReceiver(aura::Window* target,
1279                                                      bool visible) {
1280   // |this| may be deleted during a call to OnWindowVisibilityChanged() on one
1281   // of the observers. We create an local observer for that. In that case we
1282   // exit without further access to any members.
1283   WindowTracker tracker;
1284   tracker.Add(this);
1285   FOR_EACH_OBSERVER(WindowObserver, observers_,
1286                     OnWindowVisibilityChanged(target, visible));
1287   return tracker.Contains(this);
1288 }
1289
1290 bool Window::NotifyWindowVisibilityChangedDown(aura::Window* target,
1291                                                bool visible) {
1292   if (!NotifyWindowVisibilityChangedAtReceiver(target, visible))
1293     return false; // |this| was deleted.
1294   std::set<const Window*> child_already_processed;
1295   bool child_destroyed = false;
1296   do {
1297     child_destroyed = false;
1298     for (Window::Windows::const_iterator it = children_.begin();
1299          it != children_.end(); ++it) {
1300       if (!child_already_processed.insert(*it).second)
1301         continue;
1302       if (!(*it)->NotifyWindowVisibilityChangedDown(target, visible)) {
1303         // |*it| was deleted, |it| is invalid and |children_| has changed.
1304         // We exit the current for-loop and enter a new one.
1305         child_destroyed = true;
1306         break;
1307       }
1308     }
1309   } while (child_destroyed);
1310   return true;
1311 }
1312
1313 void Window::NotifyWindowVisibilityChangedUp(aura::Window* target,
1314                                              bool visible) {
1315   for (Window* window = this; window; window = window->parent()) {
1316     bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
1317     DCHECK(ret);
1318   }
1319 }
1320
1321 void Window::NotifyAncestorWindowTransformed(Window* source) {
1322   FOR_EACH_OBSERVER(WindowObserver, observers_,
1323                     OnAncestorWindowTransformed(source, this));
1324   for (Window::Windows::const_iterator it = children_.begin();
1325        it != children_.end(); ++it) {
1326     (*it)->NotifyAncestorWindowTransformed(source);
1327   }
1328 }
1329
1330 void Window::OnWindowBoundsChanged(const gfx::Rect& old_bounds) {
1331   if (layer()) {
1332     bounds_ = layer()->bounds();
1333     if (parent_ && !parent_->layer()) {
1334       gfx::Vector2d offset;
1335       aura::Window* ancestor_with_layer =
1336           parent_->GetAncestorWithLayer(&offset);
1337       if (ancestor_with_layer)
1338         bounds_.Offset(-offset);
1339     }
1340   }
1341
1342   if (layout_manager_)
1343     layout_manager_->OnWindowResized();
1344   if (delegate_)
1345     delegate_->OnBoundsChanged(old_bounds, bounds());
1346   FOR_EACH_OBSERVER(WindowObserver,
1347                     observers_,
1348                     OnWindowBoundsChanged(this, old_bounds, bounds()));
1349 }
1350
1351 bool Window::CleanupGestureState() {
1352   bool state_modified = false;
1353   state_modified |= ui::GestureRecognizer::Get()->CancelActiveTouches(this);
1354   state_modified |=
1355       ui::GestureRecognizer::Get()->CleanupStateForConsumer(this);
1356   for (Window::Windows::iterator iter = children_.begin();
1357        iter != children_.end();
1358        ++iter) {
1359     state_modified |= (*iter)->CleanupGestureState();
1360   }
1361   return state_modified;
1362 }
1363
1364 void Window::OnPaintLayer(gfx::Canvas* canvas) {
1365   Paint(canvas);
1366 }
1367
1368 void Window::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
1369   DCHECK(layer());
1370   FOR_EACH_OBSERVER(WindowObserver,
1371                     observers_,
1372                     OnDelegatedFrameDamage(this, damage_rect_in_dip));
1373 }
1374
1375 base::Closure Window::PrepareForLayerBoundsChange() {
1376   return base::Bind(&Window::OnWindowBoundsChanged, base::Unretained(this),
1377                     bounds());
1378 }
1379
1380 bool Window::CanAcceptEvent(const ui::Event& event) {
1381   // The client may forbid certain windows from receiving events at a given
1382   // point in time.
1383   client::EventClient* client = client::GetEventClient(GetRootWindow());
1384   if (client && !client->CanProcessEventsWithinSubtree(this))
1385     return false;
1386
1387   // We need to make sure that a touch cancel event and any gesture events it
1388   // creates can always reach the window. This ensures that we receive a valid
1389   // touch / gesture stream.
1390   if (event.IsEndingEvent())
1391     return true;
1392
1393   if (!IsVisible())
1394     return false;
1395
1396   // The top-most window can always process an event.
1397   if (!parent_)
1398     return true;
1399
1400   // For located events (i.e. mouse, touch etc.), an assumption is made that
1401   // windows that don't have a default event-handler cannot process the event
1402   // (see more in GetWindowForPoint()). This assumption is not made for key
1403   // events.
1404   return event.IsKeyEvent() || target_handler();
1405 }
1406
1407 ui::EventTarget* Window::GetParentTarget() {
1408   if (IsRootWindow()) {
1409     return client::GetEventClient(this) ?
1410         client::GetEventClient(this)->GetToplevelEventTarget() :
1411             Env::GetInstance();
1412   }
1413   return parent_;
1414 }
1415
1416 scoped_ptr<ui::EventTargetIterator> Window::GetChildIterator() const {
1417   return scoped_ptr<ui::EventTargetIterator>(
1418       new ui::EventTargetIteratorImpl<Window>(children()));
1419 }
1420
1421 ui::EventTargeter* Window::GetEventTargeter() {
1422   return targeter_.get();
1423 }
1424
1425 void Window::ConvertEventToTarget(ui::EventTarget* target,
1426                                   ui::LocatedEvent* event) {
1427   event->ConvertLocationToTarget(this,
1428                                  static_cast<Window*>(target));
1429 }
1430
1431 void Window::UpdateLayerName() {
1432 #if !defined(NDEBUG)
1433   DCHECK(layer());
1434
1435   std::string layer_name(name_);
1436   if (layer_name.empty())
1437     layer_name = "Unnamed Window";
1438
1439   if (id_ != -1)
1440     layer_name += " " + base::IntToString(id_);
1441
1442   layer()->set_name(layer_name);
1443 #endif
1444 }
1445
1446 bool Window::ContainsMouse() {
1447   bool contains_mouse = false;
1448   if (IsVisible()) {
1449     WindowTreeHost* host = GetHost();
1450     contains_mouse = host &&
1451         ContainsPointInRoot(host->dispatcher()->GetLastMouseLocationInRoot());
1452   }
1453   return contains_mouse;
1454 }
1455
1456 const Window* Window::GetAncestorWithLayer(gfx::Vector2d* offset) const {
1457   for (const aura::Window* window = this; window; window = window->parent()) {
1458     if (window->layer())
1459       return window;
1460     if (offset)
1461       *offset += window->bounds().OffsetFromOrigin();
1462   }
1463   if (offset)
1464     *offset = gfx::Vector2d();
1465   return NULL;
1466 }
1467
1468 }  // namespace aura