Remove some pass-thrus on RootWindow API in favor of exposing the RootWindowHost again.

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 126 matching lines @@
   if (GetProp(window, kWidgetOwnerProperty) == widget)
     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()->GetDispatcher()->GetAcceleratedWidget();
+    HWND parent = widget->GetNativeView()->GetDispatcher()->host()->
+        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()->GetDispatcher()->
-        GetAcceleratedWidget();
+        host()->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 &&
            GetParent(i->second.window) != window) {
@@ skipping 402 matching lines @@
     return;
   host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
   delegated_frame_evictor_->SetVisible(false);
   released_front_lock_ = NULL;
 
 #if defined(OS_WIN)
   constrained_rects_.clear();
   aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   if (dispatcher) {
-    HWND parent = dispatcher->GetAcceleratedWidget();
+    HWND parent = dispatcher->host()->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
   // For a SetSize operation, we don't care what coordinate system the origin
   // of the window is in, it's only important to make sure that the origin
@@ skipping 86 matching lines @@
 }
 
 gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
   return window_;
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
 #if defined(OS_WIN)
   aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   if (dispatcher) {
-    HWND window = dispatcher->GetAcceleratedWidget();
+    HWND window = dispatcher->host()->GetAcceleratedWidget();
     return reinterpret_cast<gfx::NativeViewId>(window);
   }
 #endif
   return static_cast<gfx::NativeViewId>(NULL);
 }
 
 gfx::NativeViewAccessible RenderWidgetHostViewAura::GetNativeViewAccessible() {
 #if defined(OS_WIN)
   aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   if (!dispatcher)
     return static_cast<gfx::NativeViewAccessible>(NULL);
-  HWND hwnd = dispatcher->GetAcceleratedWidget();
+  HWND hwnd = dispatcher->host()->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::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   if (!dispatcher)
     return NULL;
-  HWND hwnd = dispatcher->GetAcceleratedWidget();
+  HWND hwnd = dispatcher->host()->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_->GetDispatcher()->GetAcceleratedWidget();
+  HWND parent = window_->GetDispatcher()->host()->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 164 matching lines @@
       continue;
 
     SchedulePaintIfNotInClip(rect, clip_rect);
 
 #if defined(OS_WIN)
     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 = dispatcher->GetAcceleratedWidget();
+      HWND hwnd = dispatcher->host()->GetAcceleratedWidget();
       PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
     }
 #endif  // defined(OS_WIN)
   }
 }
 
 void RenderWidgetHostViewAura::RenderProcessGone(base::TerminationStatus status,
                                                  int error_code) {
   UpdateCursorIfOverSelf();
   Destroy();
@@ skipping 295 matching lines @@
     const std::vector<gfx::Rect>& rects) {
   if (rects == constrained_rects_)
     return;
   constrained_rects_ = rects;
   UpdateCutoutRects();
 }
 
 void RenderWidgetHostViewAura::UpdateCutoutRects() {
   if (!window_->GetRootWindow())
     return;
-  HWND parent = window_->GetDispatcher()->GetAcceleratedWidget();
+  HWND parent = window_->GetDispatcher()->host()->GetAcceleratedWidget();
   CutoutRectsParams params;
   params.widget = this;
   params.cutout_rects = constrained_rects_;
   params.geometry = &plugin_window_moves_;
   LPARAM lparam = reinterpret_cast<LPARAM>(&params);
   EnumChildWindows(parent, SetCutoutRectsCallback, lparam);
 }
 #endif
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
@@ skipping 683 matching lines @@
 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::WindowEventDispatcher* dispatcher = top_level->GetDispatcher();
   if (!dispatcher)
     return top_level->GetBoundsInScreen();
-  HWND hwnd = dispatcher->GetAcceleratedWidget();
+  HWND hwnd = dispatcher->host()->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 96 matching lines @@
     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);
 
-  root_window->GetDispatcher()->ConfineCursorToWindow();
+  root_window->GetDispatcher()->host()->ConfineCursorToRootWindow();
   return true;
 }
 
 void RenderWidgetHostViewAura::UnlockMouse() {
   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 =
       aura::client::GetCursorClient(root_window);
   if (cursor_client) {
     cursor_client->UnlockCursor();
     cursor_client->ShowCursor();
   }
 
   if (aura::client::GetTooltipClient(root_window))
     aura::client::GetTooltipClient(root_window)->SetTooltipsEnabled(true);
 
   host_->LostMouseLock();
-  root_window->GetDispatcher()->UnConfineCursor();
+  root_window->GetDispatcher()->host()->UnConfineCursor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::TextInputClient implementation:
 void RenderWidgetHostViewAura::SetCompositionText(
     const ui::CompositionText& composition) {
   if (!host_)
     return;
 
   // ui::CompositionUnderline should be identical to
@@ skipping 335 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_->GetDispatcher()->GetAcceleratedWidget();
+    parent = window_->GetDispatcher()->host()->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 197 matching lines @@
     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::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
     if (dispatcher) {
-      HWND parent = dispatcher->GetAcceleratedWidget();
+      HWND parent = dispatcher->host()->GetAcceleratedWidget();
       HWND toplevel_hwnd = ::GetAncestor(parent, GA_ROOT);
       EnumThreadWindows(GetCurrentThreadId(),
                         DismissOwnedPopups,
                         reinterpret_cast<LPARAM>(toplevel_hwnd));
     }
 #endif
     blink::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 437 matching lines @@
 
   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() };
   aura::WindowEventDispatcher* dispatcher = root_window->GetDispatcher();
-  if (dispatcher->GetAcceleratedWidget() != ::WindowFromPoint(windows_point))
+  if (dispatcher->host()->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;
 
@@ skipping 176 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content