Rename gfx::Display/Screen to display::Display/Screen in ash

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/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/host/root_window_transformer.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "third_party/skia/include/utils/SkMatrix44.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/dip_util.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size_conversions.h"
-#include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform.h"
 
-DECLARE_WINDOW_PROPERTY_TYPE(gfx::Display::Rotation);
+DECLARE_WINDOW_PROPERTY_TYPE(display::Display::Rotation);
 
 namespace ash {
 namespace {
 
 #if defined(OS_WIN)
-DEFINE_WINDOW_PROPERTY_KEY(gfx::Display::Rotation, kRotationPropertyKey,
-                           gfx::Display::ROTATE_0);
+DEFINE_WINDOW_PROPERTY_KEY(display::Display::Rotation,
+                           kRotationPropertyKey,
+                           display::Display::ROTATE_0);
 #endif
 
 // Round near zero value to zero.
 void RoundNearZero(gfx::Transform* transform) {
   const float kEpsilon = 0.001f;
   SkMatrix44& matrix = transform->matrix();
   for (int x = 0; x < 4; ++x) {
     for (int y = 0; y < 4; ++y) {
       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::Window* root_window,
-                                       const gfx::Display& display) {
+                                       const display::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.
   if (info.GetActiveRotation() ==
       root_window->GetProperty(kRotationPropertyKey)) {
     return gfx::Transform();
   }
   root_window->SetProperty(kRotationPropertyKey, info.GetActiveRotation());
 #endif
 
   gfx::Transform rotate;
   // The origin is (0, 0), so the translate width/height must be reduced by
   // 1 pixel.
   float one_pixel = 1.0f / display.device_scale_factor();
   switch (info.GetActiveRotation()) {
-    case gfx::Display::ROTATE_0:
+    case display::Display::ROTATE_0:
       break;
-    case gfx::Display::ROTATE_90:
+    case display::Display::ROTATE_90:
       rotate.Translate(display.bounds().height() - one_pixel, 0);
       rotate.Rotate(90);
       break;
-    case gfx::Display::ROTATE_270:
+    case display::Display::ROTATE_270:
       rotate.Translate(0, display.bounds().width() - one_pixel);
       rotate.Rotate(270);
       break;
-    case gfx::Display::ROTATE_180:
+    case display::Display::ROTATE_180:
       rotate.Translate(display.bounds().width() - one_pixel,
                        display.bounds().height() - one_pixel);
       rotate.Rotate(180);
       break;
   }
 
   RoundNearZero(&rotate);
   return rotate;
 }
 
@@ skipping 21 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 CreateMirrorTransform(const gfx::Display& display) {
+gfx::Transform CreateMirrorTransform(const display::Display& display) {
   gfx::Transform transform;
   transform.matrix().set3x3(-1, 0, 0,
                             0, 1, 0,
                             0, 0, 1);
   transform.Translate(-display.size().width(), 0);
   return transform;
 }
 
 // RootWindowTransformer for ash environment.
 class AshRootWindowTransformer : public RootWindowTransformer {
  public:
-  AshRootWindowTransformer(aura::Window* root,
-                           const gfx::Display& display)
+  AshRootWindowTransformer(aura::Window* root, const display::Display& display)
       : root_window_(root) {
     DisplayManager* display_manager = Shell::GetInstance()->display_manager();
     DisplayInfo info = display_manager->GetDisplayInfo(display.id());
     host_insets_ = info.GetOverscanInsetsInPixel();
     root_window_ui_scale_ = info.GetEffectiveUIScale();
     root_window_bounds_transform_ =
         CreateInsetsAndScaleTransform(host_insets_,
                                       display.device_scale_factor(),
                                       root_window_ui_scale_) *
         CreateRotationTransform(root, display);
@@ skipping 118 matching lines @@
   gfx::Transform transform_;
   gfx::Rect root_bounds_;
   gfx::Insets insets_;
 
   DISALLOW_COPY_AND_ASSIGN(MirrorRootWindowTransformer);
 };
 
 class PartialBoundsRootWindowTransformer : public RootWindowTransformer {
  public:
   PartialBoundsRootWindowTransformer(const gfx::Rect& screen_bounds,
-                                     const gfx::Display& display) {
-    gfx::Display unified_display =
-        gfx::Screen::GetScreen()->GetPrimaryDisplay();
+                                     const display::Display& display) {
+    display::Display unified_display =
+        display::Screen::GetScreen()->GetPrimaryDisplay();
     DisplayInfo display_info =
         Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
     root_bounds_ = gfx::Rect(display_info.bounds_in_native().size());
     float scale = root_bounds_.height() /
                   static_cast<float>(screen_bounds.height()) /
                   unified_display.device_scale_factor();
     transform_.Scale(scale, scale);
     transform_.Translate(-SkIntToMScalar(display.bounds().x()),
                          -SkIntToMScalar(display.bounds().y()));
   }
@@ skipping 14 matching lines @@
   gfx::Transform transform_;
   gfx::Rect root_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(PartialBoundsRootWindowTransformer);
 };
 
 }  // namespace
 
 RootWindowTransformer* CreateRootWindowTransformerForDisplay(
     aura::Window* root,
-    const gfx::Display& display) {
+    const display::Display& display) {
   return new AshRootWindowTransformer(root, display);
 }
 
 RootWindowTransformer* CreateRootWindowTransformerForMirroredDisplay(
     const DisplayInfo& source_display_info,
     const DisplayInfo& mirror_display_info) {
   return new MirrorRootWindowTransformer(source_display_info,
                                          mirror_display_info);
 }
 
 RootWindowTransformer* CreateRootWindowTransformerForUnifiedDesktop(
     const gfx::Rect& screen_bounds,
-    const gfx::Display& display) {
+    const display::Display& display) {
   return new PartialBoundsRootWindowTransformer(screen_bounds, display);
 }
 
 }  // namespace ash