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

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 155 matching lines @@
     SetParent(window, ui::GetHiddenWindow());
   return TRUE;
 }
 
 BOOL CALLBACK ShowWindowsCallback(HWND window, LPARAM param) {
   RenderWidgetHostViewAura* widget =
       reinterpret_cast<RenderWidgetHostViewAura*>(param);
 
   if (GetProp(window, kWidgetOwnerProperty) == widget) {
     HWND parent =
-        widget->GetNativeView()->GetRootWindow()->GetAcceleratedWidget();
+        widget->GetNativeView()->GetDispatcher()->GetAcceleratedWidget();
     SetParent(window, parent);
   }
   return TRUE;
 }
 
 struct CutoutRectsParams {
   RenderWidgetHostViewAura* widget;
   std::vector<gfx::Rect> cutout_rects;
   std::map<HWND, WebPluginGeometry>* geometry;
 };
 
 // Used to update the region for the windowed plugin to draw in. We start with
 // the clip rect from the renderer, then remove the cutout rects from the
 // renderer, and then remove the transient windows from the root window and the
 // constrained windows from the parent window.
 BOOL CALLBACK SetCutoutRectsCallback(HWND window, LPARAM param) {
   CutoutRectsParams* params = reinterpret_cast<CutoutRectsParams*>(param);
 
   if (GetProp(window, kWidgetOwnerProperty) == params->widget) {
     // First calculate the offset of this plugin from the root window, since
     // the cutouts are relative to the root window.
-    HWND parent = params->widget->GetNativeView()->GetRootWindow()->
+    HWND parent = params->widget->GetNativeView()->GetDispatcher()->
         GetAcceleratedWidget();
     POINT offset;
     offset.x = offset.y = 0;
     MapWindowPoints(window, parent, &offset, 1);
 
     // Now get the cached clip rect and cutouts for this plugin window that came
     // from the renderer.
     std::map<HWND, WebPluginGeometry>::iterator i = params->geometry->begin();
     while (i != params->geometry->end() &&
            i->second.window != window &&
@@ skipping 182 matching lines @@
 }  // namespace
 
 // We need to watch for mouse events outside a Web Popup or its parent
 // and dismiss the popup for certain events.
 class RenderWidgetHostViewAura::EventFilterForPopupExit :
     public ui::EventHandler {
  public:
   explicit EventFilterForPopupExit(RenderWidgetHostViewAura* rwhva)
       : rwhva_(rwhva) {
     DCHECK(rwhva_);
-    aura::RootWindow* root_window = rwhva_->window_->GetRootWindow();
+    aura::Window* root_window = rwhva_->window_->GetRootWindow();
     DCHECK(root_window);
     root_window->AddPreTargetHandler(this);
   }
 
   virtual ~EventFilterForPopupExit() {
-    aura::RootWindow* root_window = rwhva_->window_->GetRootWindow();
+    aura::Window* root_window = rwhva_->window_->GetRootWindow();
     DCHECK(root_window);
     root_window->RemovePreTargetHandler(this);
   }
 
   // Overridden from ui::EventHandler
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     rwhva_->ApplyEventFilterForPopupExit(event);
   }
 
  private:
@@ skipping 108 matching lines @@
     // is not known now.
   }
 
   virtual void OnRemoveTransientChild(aura::Window* window,
                                       aura::Window* transient) OVERRIDE {
     transient->RemoveObserver(this);
     SendPluginCutoutRects();
   }
 
   aura::Window* GetToplevelWindow() {
-    aura::RootWindow* root = view_->window_->GetRootWindow();
+    aura::Window* root = view_->window_->GetRootWindow();
     if (!root)
       return NULL;
     aura::client::ActivationClient* activation_client =
         aura::client::GetActivationClient(root);
     if (!activation_client)
       return NULL;
     return activation_client->GetToplevelWindow(view_->window_);
   }
 
   void StopObserving() {
@@ skipping 91 matching lines @@
     // similar mechanism to ensure a second popup doesn't cause the first one
     // to never get a chance to filter events. See crbug.com/160589.
     DCHECK(old_child->popup_parent_host_view_ == popup_parent_host_view_);
     old_child->popup_parent_host_view_ = NULL;
   }
   popup_parent_host_view_->popup_child_host_view_ = this;
   window_->SetType(aura::client::WINDOW_TYPE_MENU);
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
 
-  aura::RootWindow* root = popup_parent_host_view_->window_->GetRootWindow();
+  aura::Window* root = popup_parent_host_view_->window_->GetRootWindow();
   aura::client::ParentWindowWithContext(window_, root, bounds_in_screen);
 
   // TODO(erg): While I could make sure details of the WindowTreeClient are
   // hidden behind aura, hiding the details of the ScreenPositionClient will
   // take another effort.
   aura::client::ScreenPositionClient* screen_position_client =
       aura::client::GetScreenPositionClient(root);
   gfx::Point origin_in_parent(bounds_in_screen.origin());
   if (screen_position_client) {
     screen_position_client->ConvertPointFromScreen(
         window_->parent(), &origin_in_parent);
   }
   SetBounds(gfx::Rect(origin_in_parent, bounds_in_screen.size()));
   Show();
 }
 
 void RenderWidgetHostViewAura::InitAsFullscreen(
     RenderWidgetHostView* reference_host_view) {
   is_fullscreen_ = true;
   window_->SetType(aura::client::WINDOW_TYPE_NORMAL);
   window_->Init(ui::LAYER_TEXTURED);
   window_->SetName("RenderWidgetHostViewAura");
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
 
-  aura::RootWindow* parent = NULL;
+  aura::Window* parent = NULL;
   gfx::Rect bounds;
   if (reference_host_view) {
     aura::Window* reference_window =
         static_cast<RenderWidgetHostViewAura*>(reference_host_view)->window_;
     if (reference_window) {
       host_tracker_.reset(new aura::WindowTracker);
       host_tracker_->Add(reference_window);
     }
     gfx::Display display = gfx::Screen::GetScreenFor(window_)->
         GetDisplayNearestWindow(reference_window);
@@ skipping 10 matching lines @@
 }
 
 void RenderWidgetHostViewAura::WasShown() {
   DCHECK(host_);
   if (!host_->is_hidden())
     return;
   host_->WasShown();
   if (framebuffer_holder_)
     FrameMemoryManager::GetInstance()->SetFrameVisibility(this, true);
 
-  aura::RootWindow* root = window_->GetRootWindow();
+  aura::Window* root = window_->GetRootWindow();
   if (root) {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root);
     if (cursor_client)
       NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
 
   if (!current_surface_.get() && host_->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
     ui::Compositor* compositor = GetCompositor();
@@ skipping 11 matching lines @@
 void RenderWidgetHostViewAura::WasHidden() {
   if (!host_ || host_->is_hidden())
     return;
   host_->WasHidden();
   if (framebuffer_holder_)
     FrameMemoryManager::GetInstance()->SetFrameVisibility(this, false);
 
   released_front_lock_ = NULL;
 
 #if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (root_window) {
-    HWND parent = root_window->GetAcceleratedWidget();
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  if (dispatcher) {
+    HWND parent = dispatcher->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
   SetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
 void RenderWidgetHostViewAura::SetBounds(const gfx::Rect& rect) {
   if (HasDisplayPropertyChanged(window_))
     host_->InvalidateScreenInfo();
 
   window_->SetBounds(rect);
   host_->WasResized();
   MaybeCreateResizeLock();
   if (touch_editing_client_) {
     touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
         selection_focus_rect_);
   }
 }
 
 void RenderWidgetHostViewAura::MaybeCreateResizeLock() {
   if (!ShouldCreateResizeLock())
     return;
-  DCHECK(window_->GetRootWindow());
-  DCHECK(window_->GetRootWindow()->compositor());
+  DCHECK(window_->GetDispatcher());
+  DCHECK(window_->GetDispatcher()->compositor());
 
   // Listen to changes in the compositor lock state.
-  ui::Compositor* compositor = window_->GetRootWindow()->compositor();
+  ui::Compositor* compositor = window_->GetDispatcher()->compositor();
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   bool defer_compositor_lock =
       can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
       can_lock_compositor_ == NO_PENDING_COMMIT;
 
   if (can_lock_compositor_ == YES)
     can_lock_compositor_ = YES_DID_LOCK;
 
@@ skipping 17 matching lines @@
 
   if (host_->should_auto_resize())
     return false;
   if (!host_->is_accelerated_compositing_active())
     return false;
 
   gfx::Size desired_size = window_->bounds().size();
   if (desired_size == current_frame_size_)
     return false;
 
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (!root_window)
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  if (!dispatcher)
     return false;
 
-  ui::Compositor* compositor = root_window->compositor();
+  ui::Compositor* compositor = dispatcher->compositor();
   if (!compositor)
     return false;
 
   return true;
 }
 
 scoped_ptr<ResizeLock> RenderWidgetHostViewAura::CreateResizeLock(
     bool defer_compositor_lock) {
   gfx::Size desired_size = window_->bounds().size();
   return scoped_ptr<ResizeLock>(new CompositorResizeLock(
-      window_->GetRootWindow(),
+      window_->GetDispatcher(),
       desired_size,
       defer_compositor_lock,
       base::TimeDelta::FromMilliseconds(kResizeLockTimeoutMs)));
 }
 
 gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
   return window_;
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
 #if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (root_window) {
-    HWND window = root_window->GetAcceleratedWidget();
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  if (dispatcher) {
+    HWND window = dispatcher->GetAcceleratedWidget();
     return reinterpret_cast<gfx::NativeViewId>(window);
   }
 #endif
   return static_cast<gfx::NativeViewId>(NULL);
 }
 
 gfx::NativeViewAccessible RenderWidgetHostViewAura::GetNativeViewAccessible() {
 #if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (!root_window)
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  if (!dispatcher)
     return static_cast<gfx::NativeViewAccessible>(NULL);
-  HWND hwnd = root_window->GetAcceleratedWidget();
+  HWND hwnd = dispatcher->GetAcceleratedWidget();
 
   BrowserAccessibilityManager* manager =
       GetOrCreateBrowserAccessibilityManager();
   if (manager)
     return manager->GetRoot()->ToBrowserAccessibilityWin();
 #endif
 
   NOTIMPLEMENTED();
   return static_cast<gfx::NativeViewAccessible>(NULL);
 }
 
 BrowserAccessibilityManager*
 RenderWidgetHostViewAura::GetOrCreateBrowserAccessibilityManager() {
   BrowserAccessibilityManager* manager = GetBrowserAccessibilityManager();
   if (manager)
     return manager;
 
 #if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (!root_window)
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  if (!dispatcher)
     return NULL;
-  HWND hwnd = root_window->GetAcceleratedWidget();
+  HWND hwnd = dispatcher->GetAcceleratedWidget();
 
   // The accessible_parent may be NULL at this point. The WebContents will pass
   // it down to this instance (by way of the RenderViewHost and
   // RenderWidgetHost) when it is known. This instance will then set it on its
   // BrowserAccessibilityManager.
   gfx::NativeViewAccessible accessible_parent =
       host_->GetParentNativeViewAccessible();
 
   manager = new BrowserAccessibilityManagerWin(
       hwnd, accessible_parent,
@@ skipping 10 matching lines @@
 void RenderWidgetHostViewAura::MovePluginWindows(
     const gfx::Vector2d& scroll_offset,
     const std::vector<WebPluginGeometry>& plugin_window_moves) {
 #if defined(OS_WIN)
   // We need to clip the rectangle to the tab's viewport, otherwise we will draw
   // over the browser UI.
   if (!window_->GetRootWindow()) {
     DCHECK(plugin_window_moves.empty());
     return;
   }
-  HWND parent = window_->GetRootWindow()->GetAcceleratedWidget();
+  HWND parent = window_->GetDispatcher()->GetAcceleratedWidget();
   gfx::Rect view_bounds = window_->GetBoundsInRootWindow();
   std::vector<WebPluginGeometry> moves = plugin_window_moves;
 
   gfx::Rect view_port(scroll_offset.x(), scroll_offset.y(), view_bounds.width(),
                       view_bounds.height());
 
   for (size_t i = 0; i < moves.size(); ++i) {
     gfx::Rect clip(moves[i].clip_rect);
     gfx::Vector2d view_port_offset(
         moves[i].window_rect.OffsetFromOrigin() + scroll_offset);
@@ skipping 154 matching lines @@
   if (paint_canvas_) {
     SkRect sk_clip_rect;
     if (paint_canvas_->sk_canvas()->getClipBounds(&sk_clip_rect))
       clip_rect = gfx::ToEnclosingRect(gfx::SkRectToRectF(sk_clip_rect));
   }
 
   if (!scroll_rect.IsEmpty())
     SchedulePaintIfNotInClip(scroll_rect, clip_rect);
 
 #if defined(OS_WIN)
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
 #endif
   for (size_t i = 0; i < copy_rects.size(); ++i) {
     gfx::Rect rect = gfx::SubtractRects(copy_rects[i], scroll_rect);
     if (rect.IsEmpty())
       continue;
 
     SchedulePaintIfNotInClip(rect, clip_rect);
 
 #if defined(OS_WIN)
-    if (root_window) {
+    if (dispatcher) {
       // Send the invalid rect in screen coordinates.
       gfx::Rect screen_rect = GetViewBounds();
       gfx::Rect invalid_screen_rect(rect);
       invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
-      HWND hwnd = root_window->GetAcceleratedWidget();
+      HWND hwnd = dispatcher->GetAcceleratedWidget();
       PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
     }
 #endif  // defined(OS_WIN)
   }
 }
 
 void RenderWidgetHostViewAura::RenderProcessGone(base::TerminationStatus status,
                                                  int error_code) {
   UpdateCursorIfOverSelf();
   Destroy();
 }
 
 void RenderWidgetHostViewAura::Destroy() {
   // Beware, this function is not called on all destruction paths. It will
   // implicitly end up calling ~RenderWidgetHostViewAura though, so all
   // destruction/cleanup code should happen there, not here.
   in_shutdown_ = true;
   delete window_;
 }
 
 void RenderWidgetHostViewAura::SetTooltipText(const string16& tooltip_text) {
   tooltip_ = tooltip_text;
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   aura::client::TooltipClient* tooltip_client =
       aura::client::GetTooltipClient(root_window);
   if (tooltip_client) {
     tooltip_client->UpdateTooltip(window_);
     // Content tooltips should be visible indefinitely.
     tooltip_client->SetTooltipShownTimeout(window_, 0);
   }
 }
 
 void RenderWidgetHostViewAura::SelectionChanged(const string16& text,
@@ skipping 25 matching lines @@
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);
 
   if (touch_editing_client_) {
     touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
         selection_focus_rect_);
   }
 }
 
 void RenderWidgetHostViewAura::ScrollOffsetChanged() {
-  aura::RootWindow* root = window_->GetRootWindow();
+  aura::Window* root = window_->GetRootWindow();
   if (!root)
     return;
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root);
   if (cursor_client && !cursor_client->IsCursorVisible())
     cursor_client->DisableMouseEvents();
 }
 
 BackingStore* RenderWidgetHostViewAura::AllocBackingStore(
     const gfx::Size& size) {
@@ skipping 214 matching lines @@
 
 void RenderWidgetHostViewAura::UpdateConstrainedWindowRects(
     const std::vector<gfx::Rect>& rects) {
   constrained_rects_ = rects;
   UpdateCutoutRects();
 }
 
 void RenderWidgetHostViewAura::UpdateCutoutRects() {
   if (!window_->GetRootWindow())
     return;
-  HWND parent = window_->GetRootWindow()->GetAcceleratedWidget();
+  HWND parent = window_->GetDispatcher()->GetAcceleratedWidget();
   CutoutRectsParams params;
   params.widget = this;
   params.cutout_rects.assign(transient_rects_.begin(), transient_rects_.end());
   params.cutout_rects.insert(params.cutout_rects.end(),
                              constrained_rects_.begin(),
                              constrained_rects_.end());
   params.geometry = &plugin_window_moves_;
   LPARAM lparam = reinterpret_cast<LPARAM>(&params);
   EnumChildWindows(parent, SetCutoutRectsCallback, lparam);
 }
@@ skipping 709 matching lines @@
   GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
 #if defined(OS_WIN)
   // aura::Window::GetBoundsInScreen doesn't take non-client area into
   // account.
   RECT window_rect = {0};
 
   aura::Window* top_level = window_->GetToplevelWindow();
-  aura::RootWindow* root_window = top_level->GetRootWindow();
-  if (!root_window)
+  aura::WindowEventDispatcher* dispatcher = top_level->GetDispatcher();
+  if (!dispatcher)
     return top_level->GetBoundsInScreen();
-  HWND hwnd = root_window->GetAcceleratedWidget();
+  HWND hwnd = dispatcher->GetAcceleratedWidget();
   ::GetWindowRect(hwnd, &window_rect);
   gfx::Rect rect(window_rect);
 
   // Maximized windows are outdented from the work area by the frame thickness
   // even though this "frame" is not painted.  This confuses code (and people)
   // that think of a maximized window as corresponding exactly to the work area.
   // Correct for this by subtracting the frame thickness back off.
   if (::IsZoomed(hwnd)) {
     rect.Inset(GetSystemMetrics(SM_CXSIZEFRAME),
                GetSystemMetrics(SM_CYSIZEFRAME));
@@ skipping 11 matching lines @@
     touch_editing_client_->GestureEventAck(gesture_event_type);
 }
 
 void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
   ScopedVector<ui::TouchEvent> events;
   if (!MakeUITouchEventsFromWebTouchEvents(touch, &events,
                                            SCREEN_COORDINATES))
     return;
 
-  aura::RootWindow* root = window_->GetRootWindow();
-  // |root| is NULL during tests.
-  if (!root)
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  // |dispatcher| is NULL during tests.
+  if (!dispatcher)
     return;
 
   ui::EventResult result = (ack_result ==
       INPUT_EVENT_ACK_STATE_CONSUMED) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
   for (ScopedVector<ui::TouchEvent>::iterator iter = events.begin(),
       end = events.end(); iter != end; ++iter) {
-    root->ProcessedTouchEvent((*iter), window_, result);
+    dispatcher->ProcessedTouchEvent((*iter), window_, result);
   }
 }
 
 SyntheticGesture* RenderWidgetHostViewAura::CreateSmoothScrollGesture(
     bool scroll_down,
     int pixels_to_scroll,
     int mouse_event_x,
     int mouse_event_y) {
   return new TouchSmoothScrollGestureAura(scroll_down,
                                           pixels_to_scroll,
@@ skipping 24 matching lines @@
   if (shared_surface_handle_.is_null()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     shared_surface_handle_ = factory->CreateSharedSurfaceHandle();
     if (!shared_surface_handle_.is_null())
       factory->AddObserver(this);
   }
   return shared_surface_handle_;
 }
 
 bool RenderWidgetHostViewAura::LockMouse() {
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   if (!root_window)
     return false;
 
   if (mouse_locked_)
     return true;
 
   mouse_locked_ = true;
 #if !defined(OS_WIN)
   window_->SetCapture();
 #endif
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window);
   if (cursor_client) {
     cursor_client->HideCursor();
     cursor_client->LockCursor();
   }
 
   if (ShouldMoveToCenter()) {
     synthetic_move_sent_ = true;
     window_->MoveCursorTo(gfx::Rect(window_->bounds().size()).CenterPoint());
   }
   if (aura::client::GetTooltipClient(root_window))
     aura::client::GetTooltipClient(root_window)->SetTooltipsEnabled(false);
   return true;
 }
 
 void RenderWidgetHostViewAura::UnlockMouse() {
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   if (!mouse_locked_ || !root_window)
     return;
 
   mouse_locked_ = false;
 
 #if !defined(OS_WIN)
   window_->ReleaseCapture();
 #endif
   window_->MoveCursorTo(unlocked_mouse_position_);
   aura::client::CursorClient* cursor_client =
@@ skipping 88 matching lines @@
 
 bool RenderWidgetHostViewAura::CanComposeInline() const {
   return can_compose_inline_;
 }
 
 gfx::Rect RenderWidgetHostViewAura::ConvertRectToScreen(
     const gfx::Rect& rect) const {
   gfx::Point origin = rect.origin();
   gfx::Point end = gfx::Point(rect.right(), rect.bottom());
 
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   if (!root_window)
     return rect;
   aura::client::ScreenPositionClient* screen_position_client =
       aura::client::GetScreenPositionClient(root_window);
   if (!screen_position_client)
     return rect;
   screen_position_client->ConvertPointToScreen(window_, &origin);
   screen_position_client->ConvertPointToScreen(window_, &end);
   return gfx::Rect(origin.x(),
                    origin.y(),
                    end.x() - origin.x(),
                    end.y() - origin.y());
 }
 
 gfx::Rect RenderWidgetHostViewAura::ConvertRectFromScreen(
     const gfx::Rect& rect) const {
   gfx::Point origin = rect.origin();
   gfx::Point end = gfx::Point(rect.right(), rect.bottom());
 
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   if (root_window) {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root_window);
     screen_position_client->ConvertPointFromScreen(window_, &origin);
     screen_position_client->ConvertPointFromScreen(window_, &end);
     return gfx::Rect(origin.x(),
                      origin.y(),
                      end.x() - origin.x(),
                      end.y() - origin.y());
   }
@@ skipping 225 matching lines @@
 }
 
 void RenderWidgetHostViewAura::OnWindowDestroying() {
 #if defined(OS_WIN)
   HWND parent = NULL;
   // If the tab was hidden and it's closed, host_->is_hidden would have been
   // reset to false in RenderWidgetHostImpl::RendererExited.
   if (!window_->GetRootWindow() || host_->is_hidden()) {
     parent = ui::GetHiddenWindow();
   } else {
-    parent = window_->GetRootWindow()->GetAcceleratedWidget();
+    parent = window_->GetDispatcher()->GetAcceleratedWidget();
   }
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(parent, WindowDestroyingCallback, lparam);
 #endif
 
   // Make sure that the input method no longer references to this object before
   // this object is removed from the root window (i.e. this object loses access
   // to the input method).
   ui::InputMethod* input_method = GetInputMethod();
   if (input_method)
@@ skipping 183 matching lines @@
        event->type() == ui::ET_MOUSE_MOVED)) {
     event->StopPropagation();
     return;
   }
 
   if (event->type() == ui::ET_MOUSEWHEEL) {
 #if defined(OS_WIN)
     // We get mouse wheel/scroll messages even if we are not in the foreground.
     // So here we check if we have any owned popup windows in the foreground and
     // dismiss them.
-    aura::RootWindow* root_window = window_->GetRootWindow();
-    if (root_window) {
-      HWND parent = root_window->GetAcceleratedWidget();
+    aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+    if (dispatcher) {
+      HWND parent = dispatcher->GetAcceleratedWidget();
       HWND toplevel_hwnd = ::GetAncestor(parent, GA_ROOT);
       EnumThreadWindows(GetCurrentThreadId(),
                         DismissOwnedPopups,
                         reinterpret_cast<LPARAM>(toplevel_hwnd));
     }
 #endif
     WebKit::WebMouseWheelEvent mouse_wheel_event =
         MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent*>(event));
     if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0)
       host_->ForwardWheelEvent(mouse_wheel_event);
@@ skipping 134 matching lines @@
 
   // If a gesture is not processed by the webpage, then WebKit processes it
   // (e.g. generates synthetic mouse events).
   event->SetHandled();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::ActivationDelegate implementation:
 
 bool RenderWidgetHostViewAura::ShouldActivate() const {
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  if (!root_window)
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  if (!dispatcher)
     return true;
-  const ui::Event* event = root_window->current_event();
+  const ui::Event* event = dispatcher->current_event();
   if (!event)
     return true;
   return is_fullscreen_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura,
 //     aura::client::ActivationChangeObserver implementation:
 
 void RenderWidgetHostViewAura::OnWindowActivated(aura::Window* gained_active,
                                                  aura::Window* lost_active) {
   DCHECK(window_ == gained_active || window_ == lost_active);
   if (window_ == gained_active) {
-    const ui::Event* event = window_->GetRootWindow()->current_event();
+    const ui::Event* event = window_->GetDispatcher()->current_event();
     if (event && PointerEventActivates(*event))
       host_->OnPointerEventActivate();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::CursorClientObserver implementation:
 
 void RenderWidgetHostViewAura::OnCursorVisibilityChanged(bool is_visible) {
   NotifyRendererOfCursorVisibilityState(is_visible);
@@ skipping 219 matching lines @@
     touch_editing_client_->OnViewDestroyed();
   if (!shared_surface_handle_.is_null()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     factory->DestroySharedSurfaceHandle(shared_surface_handle_);
     factory->RemoveObserver(this);
   }
   window_observer_.reset();
 #if defined(OS_WIN)
   transient_observer_.reset();
 #endif
-  if (window_->GetRootWindow())
-    window_->GetRootWindow()->RemoveRootWindowObserver(this);
+  if (window_->GetDispatcher())
+    window_->GetDispatcher()->RemoveRootWindowObserver(this);
   UnlockMouse();
   if (popup_type_ != WebKit::WebPopupTypeNone && popup_parent_host_view_) {
     DCHECK(popup_parent_host_view_->popup_child_host_view_ == NULL ||
            popup_parent_host_view_->popup_child_host_view_ == this);
     popup_parent_host_view_->popup_child_host_view_ = NULL;
   }
   if (popup_child_host_view_) {
     DCHECK(popup_child_host_view_->popup_parent_host_view_ == NULL ||
            popup_child_host_view_->popup_parent_host_view_ == this);
     popup_child_host_view_->popup_parent_host_view_ = NULL;
@@ skipping 10 matching lines @@
   // early.
   framebuffer_holder_ = NULL;
 
   if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
   const gfx::Point screen_point =
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint();
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   if (!root_window)
     return;
 
+  aura::WindowEventDispatcher* dispatcher = root_window->GetDispatcher();
+
   gfx::Rect screen_rect = GetViewBounds();
   gfx::Point local_point = screen_point;
   local_point.Offset(-screen_rect.x(), -screen_rect.y());
 
 #if defined(OS_WIN)
   // If there's another toplevel window above us at this point (for example a
   // menu), we don't want to update the cursor.
   POINT windows_point = { screen_point.x(), screen_point.y() };
-  if (root_window->GetAcceleratedWidget() != ::WindowFromPoint(windows_point))
+  if (dispatcher->GetAcceleratedWidget() != ::WindowFromPoint(windows_point))
     return;
 #endif
   if (root_window->GetEventHandlerForPoint(local_point) != window_)
     return;
 
   gfx::NativeCursor cursor = current_cursor_.GetNativeCursor();
   // Do not show loading cursor when the cursor is currently hidden.
   if (is_loading_ && cursor != ui::kCursorNone)
     cursor = ui::kCursorPointer;
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window);
   if (cursor_client) {
     cursor_client->SetCursor(cursor);
   }
 }
 
 ui::InputMethod* RenderWidgetHostViewAura::GetInputMethod() const {
-  aura::RootWindow* root_window = window_->GetRootWindow();
+  aura::Window* root_window = window_->GetRootWindow();
   if (!root_window)
     return NULL;
   return root_window->GetProperty(aura::client::kRootWindowInputMethodKey);
 }
 
 bool RenderWidgetHostViewAura::NeedsInputGrab() {
   return popup_type_ == WebKit::WebPopupTypeSelect;
 }
 
 void RenderWidgetHostViewAura::FinishImeCompositionSession() {
@@ skipping 88 matching lines @@
   DCHECK(compositor);
 
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   can_lock_compositor_ = NO_PENDING_COMMIT;
   on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
 void RenderWidgetHostViewAura::AddedToRootWindow() {
-  window_->GetRootWindow()->AddRootWindowObserver(this);
+  window_->GetDispatcher()->AddRootWindowObserver(this);
   host_->ParentChanged(GetNativeViewId());
   UpdateScreenInfo(window_);
   if (popup_type_ != WebKit::WebPopupTypeNone)
     event_filter_for_popup_exit_.reset(new EventFilterForPopupExit(this));
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client) {
     cursor_client->AddObserver(this);
     NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
   if (current_surface_.get())
     UpdateExternalTexture();
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   event_filter_for_popup_exit_.reset();
-  window_->GetRootWindow()->RemoveRootWindowObserver(this);
+  window_->GetDispatcher()->RemoveRootWindowObserver(this);
   host_->ParentChanged(0);
   ui::Compositor* compositor = GetCompositor();
   if (current_surface_.get()) {
     // We can't get notification for commits after this point, which would
     // guarantee that the compositor isn't using an old texture any more, so
     // instead we force the layer to stop using any external resources which
     // synchronizes with the compositor thread, and makes it safe to run the
     // callback.
     window_->layer()->SetShowPaintedContent();
   }
   RunOnCommitCallbacks();
   resize_lock_.reset();
   host_->WasResized();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
 }
 
 ui::Compositor* RenderWidgetHostViewAura::GetCompositor() const {
-  aura::RootWindow* root_window = window_->GetRootWindow();
-  return root_window ? root_window->compositor() : NULL;
+  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  return dispatcher ? dispatcher->compositor() : NULL;
 }
 
 void RenderWidgetHostViewAura::DetachFromInputMethod() {
   ui::InputMethod* input_method = GetInputMethod();
   if (input_method && input_method->GetTextInputClient() == this)
     input_method->SetFocusedTextInputClient(NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content