Move ash::DisplayInfo to ui

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/common/ash_switches.h"
-#include "ash/common/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/core/SkMatrix44.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/display/display.h"
+#include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(display::Display::Rotation);
 
 namespace ash {
 namespace {
@@ skipping 15 matching lines @@
     }
   }
 }
 
 // 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 display::Display& display) {
-  DisplayInfo info =
+  ui::ManagedDisplayInfo 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)) {
@@ skipping 65 matching lines @@
   transform.Translate(-display.size().width(), 0);
   return transform;
 }
 
 // RootWindowTransformer for ash environment.
 class AshRootWindowTransformer : public RootWindowTransformer {
  public:
   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());
+    ui::ManagedDisplayInfo 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);
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAshEnableMirroredScreen)) {
       // Apply the tranform that flips the screen image horizontally so that
@@ skipping 55 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AshRootWindowTransformer);
 };
 
 // RootWindowTransformer for mirror root window. We simply copy the
 // texture (bitmap) of the source display into the mirror window, so
 // the root window bounds is the same as the source display's
 // pixel size (excluding overscan insets).
 class MirrorRootWindowTransformer : public RootWindowTransformer {
  public:
-  MirrorRootWindowTransformer(const DisplayInfo& source_display_info,
-                              const DisplayInfo& mirror_display_info) {
+  MirrorRootWindowTransformer(
+      const ui::ManagedDisplayInfo& source_display_info,
+      const ui::ManagedDisplayInfo& mirror_display_info) {
     root_bounds_ = gfx::Rect(source_display_info.bounds_in_native().size());
     gfx::Rect mirror_display_rect =
         gfx::Rect(mirror_display_info.bounds_in_native().size());
 
     bool letterbox = root_bounds_.width() * mirror_display_rect.height() >
                      root_bounds_.height() * mirror_display_rect.width();
     if (letterbox) {
       float mirror_scale_ratio =
           (static_cast<float>(root_bounds_.width()) /
            static_cast<float>(mirror_display_rect.width()));
@@ skipping 41 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MirrorRootWindowTransformer);
 };
 
 class PartialBoundsRootWindowTransformer : public RootWindowTransformer {
  public:
   PartialBoundsRootWindowTransformer(const gfx::Rect& screen_bounds,
                                      const display::Display& display) {
     display::Display unified_display =
         display::Screen::GetScreen()->GetPrimaryDisplay();
-    DisplayInfo display_info =
+    ui::ManagedDisplayInfo 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 18 matching lines @@
 
 }  // namespace
 
 RootWindowTransformer* CreateRootWindowTransformerForDisplay(
     aura::Window* root,
     const display::Display& display) {
   return new AshRootWindowTransformer(root, display);
 }
 
 RootWindowTransformer* CreateRootWindowTransformerForMirroredDisplay(
-    const DisplayInfo& source_display_info,
-    const DisplayInfo& mirror_display_info) {
+    const ui::ManagedDisplayInfo& source_display_info,
+    const ui::ManagedDisplayInfo& mirror_display_info) {
   return new MirrorRootWindowTransformer(source_display_info,
                                          mirror_display_info);
 }
 
 RootWindowTransformer* CreateRootWindowTransformerForUnifiedDesktop(
     const gfx::Rect& screen_bounds,
     const display::Display& display) {
   return new PartialBoundsRootWindowTransformer(screen_bounds, display);
 }
 
 }  // namespace ash