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

ash/rotator/screen_rotation_animator.cc

 // Copyright 2015 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/rotator/screen_rotation_animator.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/rotator/screen_rotation_animation.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/time/time.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/layer_owner.h"
 #include "ui/compositor/layer_tree_owner.h"
+#include "ui/display/display.h"
 #include "ui/gfx/animation/tween.h"
-#include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 
 namespace {
 
 // The number of degrees that the rotation animations animate through.
 const int kRotationDegrees = 20;
 
 // The time it takes for the rotation animations to run.
 const int kRotationDurationInMs = 250;
 
 // Gets the current display rotation for the display with the specified
 // |display_id|.
-gfx::Display::Rotation GetCurrentRotation(int64_t display_id) {
+display::Display::Rotation GetCurrentRotation(int64_t display_id) {
   return Shell::GetInstance()
       ->display_manager()
       ->GetDisplayInfo(display_id)
       .GetActiveRotation();
 }
 
 // Returns true if the rotation between |initial_rotation| and |new_rotation| is
 // 180 degrees.
-bool Is180DegreeFlip(gfx::Display::Rotation initial_rotation,
-                     gfx::Display::Rotation new_rotation) {
+bool Is180DegreeFlip(display::Display::Rotation initial_rotation,
+                     display::Display::Rotation new_rotation) {
   return (initial_rotation + 2) % 4 == new_rotation;
 }
 
 // A LayerAnimationObserver that will destroy the contained LayerTreeOwner when
 // notified that a layer animation has ended or was aborted.
 class LayerCleanupObserver : public ui::LayerAnimationObserver {
  public:
   explicit LayerCleanupObserver(
       std::unique_ptr<ui::LayerTreeOwner> layer_tree_owner);
   ~LayerCleanupObserver() override;
@@ skipping 72 matching lines @@
     AbortAnimations(child_layer);
   layer->GetAnimator()->AbortAllAnimations();
 }
 
 // Set the screen orientation for the given |display_id| to |new_rotation| and
 // animate the change. The animation will rotate the initial orientation's
 // layer towards the new orientation through |rotation_degrees| while fading
 // out, and the new orientation's layer will be rotated in to the
 // |new_orientation| through |rotation_degrees| arc.
 void RotateScreen(int64_t display_id,
-                  gfx::Display::Rotation new_rotation,
-                  gfx::Display::RotationSource source) {
+                  display::Display::Rotation new_rotation,
+                  display::Display::RotationSource source) {
   aura::Window* root_window = Shell::GetInstance()
                                   ->window_tree_host_manager()
                                   ->GetRootWindowForDisplayId(display_id);
 
-  const gfx::Display::Rotation initial_orientation =
+  const display::Display::Rotation initial_orientation =
       GetCurrentRotation(display_id);
 
   const gfx::Rect original_screen_bounds = root_window->GetTargetBounds();
   // 180 degree rotations should animate clock-wise.
   const int rotation_factor =
       (initial_orientation + 3) % 4 == new_rotation ? 1 : -1;
 
   const int old_layer_initial_rotation_degrees =
       (Is180DegreeFlip(initial_orientation, new_rotation) ? 180 : 90);
 
@@ skipping 83 matching lines @@
 ScreenRotationAnimator::~ScreenRotationAnimator() {
 }
 
 bool ScreenRotationAnimator::CanAnimate() const {
   return Shell::GetInstance()
       ->display_manager()
       ->GetDisplayForId(display_id_)
       .is_valid();
 }
 
-void ScreenRotationAnimator::Rotate(gfx::Display::Rotation new_rotation,
-                                    gfx::Display::RotationSource source) {
-  const gfx::Display::Rotation current_rotation =
+void ScreenRotationAnimator::Rotate(display::Display::Rotation new_rotation,
+                                    display::Display::RotationSource source) {
+  const display::Display::Rotation current_rotation =
       GetCurrentRotation(display_id_);
 
   if (current_rotation == new_rotation)
     return;
 
   RotateScreen(display_id_, new_rotation, source);
 }
 
 }  // namespace ash