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

ash/display/root_window_transformers.cc

 // Copyright (c) 2013 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/root_window_transformers.h"
 
 #include <cmath>
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
@@ skipping 32 matching lines @@
       if (std::abs(SkMScalarToFloat(matrix.get(x, y))) < kEpsilon)
         matrix.set(x, y, SkFloatToMScalar(0.0f));
     }
   }
 }
 
 // TODO(oshima): Transformers should be able to adjust itself
 // when the device scale factor is changed, instead of
 // precalculating the transform using fixed value.
 
-gfx::Transform CreateRotationTransform(aura::RootWindow* root_window,
+gfx::Transform CreateRotationTransform(aura::Window* root_window,
                                        const gfx::Display& display) {
   DisplayInfo info =
       Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
 
   // TODO(oshima): Add animation. (crossfade+rotation, or just cross-fade)
 #if defined(OS_WIN)
   // Windows 8 bots refused to resize the host window, and
   // updating the transform results in incorrectly resizing
   // the root window. Don't apply the transform unless
   // necessary so that unit tests pass on win8 bots.
@@ skipping 21 matching lines @@
       rotate.Translate(display.bounds().width() - one_pixel,
                        display.bounds().height() - one_pixel);
       rotate.Rotate(180);
       break;
   }
 
   RoundNearZero(&rotate);
   return rotate;
 }
 
-gfx::Transform CreateMagnifierTransform(aura::RootWindow* root_window) {
+gfx::Transform CreateMagnifierTransform(aura::Window* root_window) {
   MagnificationController* magnifier =
       Shell::GetInstance()->magnification_controller();
   float magnifier_scale = 1.f;
   gfx::Point magnifier_offset;
   if (magnifier && magnifier->IsEnabled()) {
     magnifier_scale = magnifier->GetScale();
     magnifier_offset = magnifier->GetWindowPosition();
   }
   gfx::Transform transform;
   if (magnifier_scale != 1.f) {
@@ skipping 10 matching lines @@
   if (insets.top() != 0 || insets.left() != 0) {
     float x_offset = insets.left() / device_scale_factor;
     float y_offset = insets.top() / device_scale_factor;
     transform.Translate(x_offset, y_offset);
   }
   float inverted_scale = 1.0f / ui_scale;
   transform.Scale(inverted_scale, inverted_scale);
   return transform;
 }
 
-gfx::Transform CreateOverscanAndUIScaleTransform(aura::RootWindow* root_window,
+gfx::Transform CreateOverscanAndUIScaleTransform(aura::Window* root_window,
                                                  const gfx::Display& display) {
   DisplayInfo info =
       Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
   return CreateInsetsAndScaleTransform(
       info.GetOverscanInsetsInPixel(),
       ui::GetDeviceScaleFactor(root_window->layer()),
       info.ui_scale());
 }
 
 // RootWindowTransformer for ash environment.
 class AshRootWindowTransformer : public aura::RootWindowTransformer {
  public:
-  AshRootWindowTransformer(aura::RootWindow* root,
+  AshRootWindowTransformer(aura::Window* root,
                            const gfx::Display& display)
       : root_window_(root) {
     root_window_bounds_transform_ =
         CreateOverscanAndUIScaleTransform(root, display) *
         CreateRotationTransform(root, display);
     transform_ = root_window_bounds_transform_ * CreateMagnifierTransform(root);
     CHECK(transform_.GetInverse(&invert_transform_));
 
     DisplayInfo info = Shell::GetInstance()->display_manager()->
         GetDisplayInfo(display.id());
@@ skipping 28 matching lines @@
     return gfx::Rect(gfx::ToFlooredSize(new_bounds.size()));
   }
 
   virtual gfx::Insets GetHostInsets() const OVERRIDE {
     return host_insets_;
   }
 
  private:
   virtual ~AshRootWindowTransformer() {}
 
-  aura::RootWindow* root_window_;
+  aura::Window* root_window_;
   gfx::Transform transform_;
 
   // The accurate representation of the inverse of the |transform_|.
   // This is used to avoid computation error caused by
   // |gfx::Transform::GetInverse|.
   gfx::Transform invert_transform_;
 
   // The transform of the root window bounds. This is used to calculate
   // the size of root window.
   gfx::Transform root_window_bounds_transform_;
@@ skipping 71 matching lines @@
   gfx::Transform transform_;
   gfx::Rect root_bounds_;
   gfx::Insets insets_;
 
   DISALLOW_COPY_AND_ASSIGN(MirrorRootWindowTransformer);
 };
 
 }  // namespace
 
 aura::RootWindowTransformer* CreateRootWindowTransformerForDisplay(
-    aura::RootWindow* root,
+    aura::Window* root,
     const gfx::Display& display) {
   return new AshRootWindowTransformer(root, display);
 }
 
 aura::RootWindowTransformer* CreateRootWindowTransformerForMirroredDisplay(
     const DisplayInfo& source_display_info,
     const DisplayInfo& mirror_display_info) {
   return new MirrorRootWindowTransformer(source_display_info,
                                          mirror_display_info);
 }
 
 }  // namespace internal
 }  // namespace ash