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);

[sky, 2013/10/24 20:59:46]

You need to set this to NULL in the destructor, otherwise ~Window is going to
use it.

   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 444 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 298 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