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

ash/display/display_controller.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 "ash/display/display_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
@@ skipping 96 matching lines @@
       break;
     case gfx::Display::ROTATE_180:
       xrandr_rotation = RR_Rotate_180;
       break;
     case gfx::Display::ROTATE_270:
       xrandr_rotation = RR_Rotate_270;
       break;
   }
 
   int internal = display.IsInternal() ? 1 : 0;
-  gfx::AcceleratedWidget xwindow = root->GetAcceleratedWidget();
+  gfx::AcceleratedWidget xwindow = root->host()->GetAcceleratedWidget();
   ui::SetIntProperty(xwindow, kInternalProp, kCARDINAL, internal);
   ui::SetIntProperty(xwindow, kRotationProp, kCARDINAL, xrandr_rotation);
   ui::SetIntProperty(xwindow,
                      kScaleFactorProp,
                      kCARDINAL,
                      100 * display.device_scale_factor());
 #endif
   scoped_ptr<aura::RootWindowTransformer> transformer(
       internal::CreateRootWindowTransformerForDisplay(root->window(), display));
   root->SetRootWindowTransformer(transformer.Pass());
@@ skipping 390 matching lines @@
     // We don't care about actual distance, only relative to other displays, so
     // using the LengthSquared() is cheaper than Length().
 
     int64 distance_squared = (center - point_in_screen).LengthSquared();
     if (closest_distance_squared < 0 ||
         closest_distance_squared > distance_squared) {
       aura::Window* root_window = GetRootWindowForDisplayId(display.id());
       aura::client::ScreenPositionClient* client =
           aura::client::GetScreenPositionClient(root_window);
       client->ConvertPointFromScreen(root_window, &center);
-      root_window->GetDispatcher()->ConvertPointToNativeScreen(&center);
+      root_window->GetDispatcher()->host()->ConvertPointToNativeScreen(&center);
       dst_root_window = root_window;
       target_location_in_native = center;
       closest_distance_squared = distance_squared;
     }
   }
-  dst_root_window->GetDispatcher()->ConvertPointFromNativeScreen(
+  dst_root_window->GetDispatcher()->host()->ConvertPointFromNativeScreen(
       &target_location_in_native);
   dst_root_window->MoveCursorTo(target_location_in_native);
 }
 
 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
   int64 id = internal::GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
@@ skipping 124 matching lines @@
   // root window itself yet because the stack may be using it.
   controller->Shutdown();
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
 }
 
 void DisplayController::OnRootWindowHostResized(const aura::RootWindow* root) {
   internal::DisplayManager* display_manager = GetDisplayManager();
   gfx::Display display = GetDisplayNearestWindow(root->window());
   if (display_manager->UpdateDisplayBounds(
           display.id(),
-          gfx::Rect(root->GetHostOrigin(), root->GetHostSize()))) {
+          root->host()->GetBounds())) {
     mirror_window_controller_->UpdateWindow();
   }
 }
 
 void DisplayController::CreateOrUpdateNonDesktopDisplay(
     const internal::DisplayInfo& info) {
   switch (GetDisplayManager()->second_display_mode()) {
     case internal::DisplayManager::MIRRORING:
       mirror_window_controller_->UpdateWindow(info);
       virtual_keyboard_window_controller_->Close();
@@ skipping 17 matching lines @@
   focus_activation_store_->Store(clear_focus);
 
   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Display display =
       Shell::GetScreen()->GetDisplayNearestPoint(point_in_screen);
   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
 
   aura::client::ScreenPositionClient* client =
       aura::client::GetScreenPositionClient(root_window);
   client->ConvertPointFromScreen(root_window, &point_in_screen);
-  root_window->GetDispatcher()->ConvertPointToNativeScreen(&point_in_screen);
+  root_window->GetDispatcher()->host()->ConvertPointToNativeScreen(
+      &point_in_screen);
   cursor_location_in_native_coords_for_restore_ = point_in_screen;
 }
 
 void DisplayController::PostDisplayConfigurationChange() {
   if (limiter_)
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   focus_activation_store_->Restore();
 
   internal::DisplayManager* display_manager = GetDisplayManager();
@@ skipping 41 matching lines @@
   root_window->Init();
 
   root_windows_[display.id()] = root_window->window();
   SetDisplayPropertiesOnHostWindow(root_window, display);
 
 #if defined(OS_CHROMEOS)
   static bool force_constrain_pointer_to_root =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshConstrainPointerToRoot);
   if (base::SysInfo::IsRunningOnChromeOS() || force_constrain_pointer_to_root)
-    root_window->ConfineCursorToWindow();
+    root_window->host()->ConfineCursorToRootWindow();
 #endif
   return root_window;
 }
 
 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 #if defined(OS_CHROMEOS) && defined(USE_X11)
   SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
   Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
 #endif
 }
 
 void DisplayController::UpdateHostWindowNames() {
 #if defined(USE_X11)
   // crbug.com/120229 - set the window title for the primary dislpay
   // to "aura_root_0" so gtalk can find the primary root window to broadcast.
   // TODO(jhorwich) Remove this once Chrome supports window-based broadcasting.
   aura::Window* primary = Shell::GetPrimaryRootWindow();
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (size_t i = 0; i < root_windows.size(); ++i) {
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow =
-        root_windows[i]->GetDispatcher()->GetAcceleratedWidget();
+        root_windows[i]->GetDispatcher()->host()->GetAcceleratedWidget();
     XStoreName(gfx::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
 }  // namespace ash