Make GetRootWindow() return a Window instead of a RootWindow.

ui/aura/window.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/animation/multi_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 Window::Window(WindowDelegate* delegate)
-    : type_(client::WINDOW_TYPE_UNKNOWN),
+    : dispatcher_(NULL),
+      type_(client::WINDOW_TYPE_UNKNOWN),
       owned_by_parent_(true),
       delegate_(delegate),
       parent_(NULL),
       transient_parent_(NULL),
       visible_(false),
       id_(-1),
       transparent_(false),
       user_data_(NULL),
       ignore_events_(false),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as the workspace code).
       observers_(ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
   set_target_handler(delegate_);
 }
 
 Window::~Window() {
   // layer_ can be NULL if Init() wasn't invoked, which can happen
   // only in tests.
   if (layer_)
     layer_->SuppressPaint();
 
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying();
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
 
   // Let the root know so that it can remove any references to us.
-  RootWindow* root_window = GetRootWindow();
-  if (root_window)
-    root_window->OnWindowDestroying(this);
+  WindowEventDispatcher* dispatcher = GetDispatcher();
+  if (dispatcher)
+    dispatcher->OnWindowDestroying(this);
 
   // Then destroy the children.
   RemoveOrDestroyChildren();
 
   // Removes ourselves from our transient parent (if it hasn't been done by the
   // RootWindow).
   if (transient_parent_)
     transient_parent_->RemoveTransientChild(this);
 
   // The window needs to be removed from the parent before calling the
@@ skipping 90 matching lines @@
   if (layer())
     UpdateLayerName(name_);
 }
 
 void Window::SetTransparent(bool transparent) {
   transparent_ = transparent;
   if (layer())
     layer_->SetFillsBoundsOpaquely(!transparent_);
 }
 
-RootWindow* Window::GetRootWindow() {
-  return const_cast<RootWindow*>(
+Window* Window::GetRootWindow() {
+  return const_cast<Window*>(
       static_cast<const Window*>(this)->GetRootWindow());
 }
 
-const RootWindow* Window::GetRootWindow() const {
+const Window* Window::GetRootWindow() const {
   return parent_ ? parent_->GetRootWindow() : NULL;
 }
 
+WindowEventDispatcher* Window::GetDispatcher() {
+  return const_cast<WindowEventDispatcher*>(const_cast<const Window*>(this)->
+      GetDispatcher());
+}
+
+const WindowEventDispatcher* Window::GetDispatcher() const {
+  const Window* root_window = GetRootWindow();
+  return root_window ? root_window->dispatcher_ : NULL;
+}
+
 void Window::Show() {
   SetVisible(true);
 }
 
 void Window::Hide() {
   for (Windows::iterator it = transient_children_.begin();
        it != transient_children_.end(); ++it) {
     (*it)->Hide();
   }
   SetVisible(false);
@@ skipping 14 matching lines @@
   //             do for now.
   if (!GetRootWindow())
     return bounds();
   gfx::Point origin = bounds().origin();
   ConvertPointToTarget(parent_, GetRootWindow(), &origin);
   return gfx::Rect(origin, bounds().size());
 }
 
 gfx::Rect Window::GetBoundsInScreen() const {
   gfx::Rect bounds(GetBoundsInRootWindow());
-  const RootWindow* root = GetRootWindow();
+  const Window* root = GetRootWindow();
   if (root) {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     if (screen_position_client) {
       gfx::Point origin = bounds.origin();
       screen_position_client->ConvertPointToScreen(root, &origin);
       bounds.set_origin(origin);
     }
   }
   return bounds;
 }
 
 void Window::SetTransform(const gfx::Transform& transform) {
-  RootWindow* root_window = GetRootWindow();
-  bool contained_mouse = IsVisible() && root_window &&
-      ContainsPointInRoot(root_window->GetLastMouseLocationInRoot());
+  WindowEventDispatcher* dispatcher = GetDispatcher();
+  bool contained_mouse = IsVisible() && dispatcher &&
+      ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
   layer()->SetTransform(transform);
-  if (root_window)
-    root_window->OnWindowTransformed(this, contained_mouse);
+  if (dispatcher)
+    dispatcher->OnWindowTransformed(this, contained_mouse);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   if (layout_manager == layout_manager_)
     return;
   layout_manager_.reset(layout_manager);
   if (!layout_manager)
     return;
   // If we're changing to a new layout manager, ensure it is aware of all the
   // existing child windows.
   for (Windows::const_iterator it = children_.begin();
        it != children_.end();
        ++it)
     layout_manager_->OnWindowAddedToLayout(*it);
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
   if (parent_ && parent_->layout_manager())
     parent_->layout_manager()->SetChildBounds(this, new_bounds);
   else
     SetBoundsInternal(new_bounds);
 }
 
 void Window::SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen,
                                const gfx::Display& dst_display) {
-  RootWindow* root = GetRootWindow();
+  Window* root = GetRootWindow();
   if (root) {
     gfx::Point origin = new_bounds_in_screen.origin();
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
     return;
   }
   SetBounds(new_bounds_in_screen);
 }
 
@@ skipping 33 matching lines @@
 }
 
 void Window::AddChild(Window* child) {
   WindowObserver::HierarchyChangeParams params;
   params.target = child;
   params.new_parent = this;
   params.old_parent = child->parent();
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
   NotifyWindowHierarchyChange(params);
 
-  RootWindow* old_root = child->GetRootWindow();
+  Window* old_root = child->GetRootWindow();
 
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
     child->parent()->RemoveChildImpl(child, this);
   child->parent_ = this;
 
   layer_->Add(child->layer_);
 
   children_.push_back(child);
   if (layout_manager_)
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
   child->OnParentChanged();
 
-  RootWindow* root_window = GetRootWindow();
+  Window* root_window = GetRootWindow();
   if (root_window && old_root != root_window) {
-    root_window->OnWindowAddedToRootWindow(child);
+    root_window->GetDispatcher()->OnWindowAddedToRootWindow(child);
     child->NotifyAddedToRootWindow();
   }
 
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
   NotifyWindowHierarchyChange(params);
 }
 
 void Window::RemoveChild(Window* child) {
   WindowObserver::HierarchyChangeParams params;
   params.target = child;
@@ skipping 55 matching lines @@
 }
 
 // static
 void Window::ConvertPointToTarget(const Window* source,
                                   const Window* target,
                                   gfx::Point* point) {
   if (!source)
     return;
   if (source->GetRootWindow() != target->GetRootWindow()) {
     client::ScreenPositionClient* source_client =
-        GetScreenPositionClient(source->GetRootWindow());
+        client::GetScreenPositionClient(source->GetRootWindow());
     source_client->ConvertPointToScreen(source, point);
 
     client::ScreenPositionClient* target_client =
-        GetScreenPositionClient(target->GetRootWindow());
+        client::GetScreenPositionClient(target->GetRootWindow());
     target_client->ConvertPointFromScreen(target, point);
   } else {
     ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
   }
 }
 
 void Window::MoveCursorTo(const gfx::Point& point_in_window) {
-  RootWindow* root_window = GetRootWindow();
+  Window* root_window = GetRootWindow();
   DCHECK(root_window);
   gfx::Point point_in_root(point_in_window);
   ConvertPointToTarget(this, root_window, &point_in_root);
-  root_window->MoveCursorTo(point_in_root);
+  root_window->GetDispatcher()->MoveCursorTo(point_in_root);
 }
 
 gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
   return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
 }
 
 void Window::SetEventFilter(ui::EventHandler* event_filter) {
   if (event_filter_)
     RemovePreTargetHandler(event_filter_.get());
   event_filter_.reset(event_filter);
@@ skipping 105 matching lines @@
   if (client && !client->CanProcessEventsWithinSubtree(this))
     return false;
 
   return parent_ && IsVisible() && parent_->CanReceiveEvents();
 }
 
 void Window::SetCapture() {
   if (!IsVisible())
     return;
 
-  RootWindow* root_window = GetRootWindow();
+  Window* root_window = GetRootWindow();
   if (!root_window)
     return;
   client::GetCaptureClient(root_window)->SetCapture(this);
 }
 
 void Window::ReleaseCapture() {
-  RootWindow* root_window = GetRootWindow();
+  Window* root_window = GetRootWindow();
   if (!root_window)
     return;
   client::GetCaptureClient(root_window)->ReleaseCapture(this);
 }
 
 bool Window::HasCapture() {
-  RootWindow* root_window = GetRootWindow();
+  Window* root_window = GetRootWindow();
   return root_window &&
       client::GetCaptureClient(root_window)->GetCaptureWindow() == this;
 }
 
 void Window::SuppressPaint() {
   layer_->SuppressPaint();
 }
 
 // {Set,Get,Clear}Property are implemented in window_property.h.
 
@@ skipping 105 matching lines @@
     OnLayerBoundsChanged(old_bounds, ContainsMouse());
 }
 
 void Window::SetVisible(bool visible) {
   if (visible == layer_->GetTargetVisibility())
     return;  // No change.
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 
-  RootWindow* root_window = GetRootWindow();
-  if (root_window)
-    root_window->DispatchMouseExitToHidingWindow(this);
+  WindowEventDispatcher* dispatcher = GetDispatcher();
+  if (dispatcher)
+    dispatcher->DispatchMouseExitToHidingWindow(this);
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
   else
     layer_->SetVisible(visible);
   visible_ = visible;
   SchedulePaint();
   if (parent_ && parent_->layout_manager_)
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
 
   if (delegate_)
     delegate_->OnWindowTargetVisibilityChanged(visible);
 
   NotifyWindowVisibilityChanged(this, visible);
 
-  if (root_window)
-    root_window->OnWindowVisibilityChanged(this, visible);
+  if (dispatcher)
+    dispatcher->OnWindowVisibilityChanged(this, visible);
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
                                   bool return_tightest,
                                   bool for_event_handling) {
   if (!IsVisible())
@@ skipping 46 matching lines @@
       return match;
   }
 
   return delegate_ ? this : NULL;
 }
 
 void Window::RemoveChildImpl(Window* child, Window* new_parent) {
   if (layout_manager_)
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
-  RootWindow* root_window = child->GetRootWindow();
-  RootWindow* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
+  Window* root_window = child->GetRootWindow();
+  Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
   if (root_window && root_window != new_root_window) {
-    root_window->OnWindowRemovedFromRootWindow(child, new_root_window);
+    root_window->GetDispatcher()->OnWindowRemovedFromRootWindow(
+        child, new_root_window);
     child->NotifyRemovingFromRootWindow();
   }
   child->parent_ = NULL;
   // We should only remove the child's layer if the child still owns that layer.
   // Someone else may have acquired ownership of it via AcquireLayer() and may
   // expect the hierarchy to go unchanged as the Window is destroyed.
   if (child->layer_owner_)
     layer_->Remove(child->layer_);
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
@@ skipping 278 matching lines @@
 
 void Window::OnLayerBoundsChanged(const gfx::Rect& old_bounds,
                                   bool contained_mouse) {
   if (layout_manager_)
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, bounds());
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnWindowBoundsChanged(this, old_bounds, bounds()));
-  RootWindow* root_window = GetRootWindow();
-  if (root_window)
-    root_window->OnWindowBoundsChanged(this, contained_mouse);
+  WindowEventDispatcher* dispatcher = GetDispatcher();
+  if (dispatcher)
+    dispatcher->OnWindowBoundsChanged(this, contained_mouse);
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
 }
 
 base::Closure Window::PrepareForLayerBoundsChange() {
   return base::Bind(&Window::OnLayerBoundsChanged, base::Unretained(this),
                     bounds(), ContainsMouse());
@@ skipping 27 matching lines @@
     base::snprintf(id_buf, sizeof(id_buf), " %d", id_);
     layer_name.append(id_buf);
   }
   layer()->set_name(layer_name);
 #endif
 }
 
 bool Window::ContainsMouse() {
   bool contains_mouse = false;
   if (IsVisible()) {
-    RootWindow* root_window = GetRootWindow();
-    contains_mouse = root_window &&
-        ContainsPointInRoot(root_window->GetLastMouseLocationInRoot());
+    WindowEventDispatcher* dispatcher = GetDispatcher();
+    contains_mouse = dispatcher &&
+        ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
   }
   return contains_mouse;
 }
 
 }  // namespace aura