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

ui/aura/root_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/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 131 matching lines @@
       touch_ids_down_(0),
       last_cursor_(ui::kCursorNull),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       event_dispatch_target_(NULL),
       synthesize_mouse_move_(false),
       move_hold_count_(0),
       event_factory_(this),
       held_event_factory_(this),
       repostable_event_factory_(this) {
+  set_dispatcher(this);
   SetName("RootWindow");
 
   compositor_.reset(new ui::Compositor(host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
 
   prop_.reset(new ui::ViewProp(host_->GetAcceleratedWidget(),
                                kRootWindowForAcceleratedWidget,
                                this));
   ui::GestureRecognizer::Get()->AddGestureEventHelper(this);
 }
@@ skipping 12 matching lines @@
 
   // Destroy child windows while we're still valid. This is also done by
   // ~Window, but by that time any calls to virtual methods overriden here (such
   // as GetRootWindow()) result in Window's implementation. By destroying here
   // we ensure GetRootWindow() still returns this.
   RemoveOrDestroyChildren();
 
   // Destroying/removing child windows may try to access |host_| (eg.
   // GetAcceleratedWidget())
   host_.reset(NULL);
+
+  set_dispatcher(NULL);
 }
 
 // static
 RootWindow* RootWindow::GetForAcceleratedWidget(
     gfx::AcceleratedWidget widget) {
   return reinterpret_cast<RootWindow*>(
       ui::ViewProp::GetValue(widget, kRootWindowForAcceleratedWidget));
 }
 
 void RootWindow::Init() {
@@ skipping 319 matching lines @@
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(scale, scale);
   transform *= transformer_->GetTransform();
   return transform;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, Window overrides:
 
-RootWindow* RootWindow::GetRootWindow() {
+Window* RootWindow::GetRootWindow() {
   return this;
 }
 
-const RootWindow* RootWindow::GetRootWindow() const {
+const Window* RootWindow::GetRootWindow() const {
   return this;
 }
 
 void RootWindow::SetTransform(const gfx::Transform& transform) {
   scoped_ptr<RootWindowTransformer> transformer(
       new SimpleRootWindowTransformer(this, transform));
   SetRootWindowTransformer(transformer.Pass());
 }
 
 bool RootWindow::CanFocus() const {
@@ skipping 68 matching lines @@
 }
 
 void RootWindow::OnWindowAddedToRootWindow(Window* attached) {
   if (attached->IsVisible() &&
       attached->ContainsPointInRoot(GetLastMouseLocationInRoot())) {
     PostMouseMoveEventAfterWindowChange();
   }
 }
 
 void RootWindow::OnWindowRemovedFromRootWindow(Window* detached,
-                                               RootWindow* new_root) {
+                                               Window* new_root) {
   DCHECK(aura::client::GetCaptureWindow(this) != this);
 
   DispatchMouseExitToHidingWindow(detached);
   OnWindowHidden(detached, new_root ? WINDOW_MOVING : WINDOW_HIDDEN);
 
   if (detached->IsVisible() &&
       detached->ContainsPointInRoot(GetLastMouseLocationInRoot())) {
     PostMouseMoveEventAfterWindowChange();
   }
 }
@@ skipping 303 matching lines @@
       mouse_pressed_handler_ : client::GetCaptureWindow(this);
   if (!target)
     target = GetEventHandlerForPoint(event->location());
   return DispatchMouseEventToTarget(event, target);
 }
 
 void RootWindow::DispatchMouseEventRepost(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_PRESSED)
     return;
   Window* target = client::GetCaptureWindow(this);
-  RootWindow* root = this;
+  WindowEventDispatcher* dispatcher = this;
   if (!target) {
     target = GetEventHandlerForPoint(event->location());
   } else {
-    root = target->GetRootWindow();
-    CHECK(root);  // Capture window better be in valid root.
+    dispatcher = target->GetDispatcher();
+    CHECK(dispatcher);  // Capture window better be in valid root.
   }
-  root->mouse_pressed_handler_ = NULL;
-  root->DispatchMouseEventToTarget(event, target);
+  dispatcher->mouse_pressed_handler_ = NULL;
+  dispatcher->DispatchMouseEventToTarget(event, target);
 }
 
 bool RootWindow::DispatchMouseEventToTarget(ui::MouseEvent* event,
                                             Window* target) {
   client::CursorClient* cursor_client = client::GetCursorClient(this);
   if (cursor_client &&
       !cursor_client->IsMouseEventsEnabled() &&
       (event->flags() & ui::EF_IS_SYNTHESIZED))
     return false;
 
@@ skipping 226 matching lines @@
 }
 
 gfx::Transform RootWindow::GetInverseRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(1.0f / scale, 1.0f / scale);
   return transformer_->GetInverseTransform() * transform;
 }
 
 }  // namespace aura