Move ash::DisplayInfo to ui

chrome/browser/extensions/display_info_provider_chromeos.cc

 // Copyright 2014 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 "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.h"
@@ skipping 299 matching lines @@
     }
 
     if ((info.overscan->top + info.overscan->bottom) * 2 > screen_height) {
       *error = "Vertical overscan is more than half of the screen height.";
       return false;
     }
   }
 
   // Set the display mode.
   if (info.display_mode) {
-    scoped_refptr<ash::ManagedDisplayMode> current_mode =
+    scoped_refptr<display::ManagedDisplayMode> current_mode =
         display_manager->GetActiveModeForDisplayId(id);
     // Copy properties not set in the UI from the current mode.
     gfx::Size size(info.display_mode->width_in_native_pixels,
                    info.display_mode->height_in_native_pixels);
 
     // NB: info.display_mode is neither an ash::DisplayMode or a
     // ui::DisplayMode.
-    scoped_refptr<ash::ManagedDisplayMode> new_mode(new ash::ManagedDisplayMode(
-        size, current_mode->refresh_rate(), current_mode->is_interlaced(),
-        info.display_mode->is_native, info.display_mode->ui_scale,
-        info.display_mode->device_scale_factor));
+    scoped_refptr<display::ManagedDisplayMode> new_mode(
+        new display::ManagedDisplayMode(
+            size, current_mode->refresh_rate(), current_mode->is_interlaced(),
+            info.display_mode->is_native, info.display_mode->ui_scale,
+            info.display_mode->device_scale_factor));
 
     if (new_mode->IsEquivalent(current_mode)) {
       *error = "Display mode matches current mode.";
       return false;
     }
 
     if (!display_manager->SetDisplayMode(id, new_mode)) {
       *error = "Unable to set the display mode.";
       return false;
     }
 
     if (!display::Display::IsInternalDisplayId(id)) {
       // For external displays, show a notification confirming the resolution
       // change.
       ash::Shell::GetInstance()
           ->resolution_notification_controller()
           ->PrepareNotification(id, current_mode, new_mode,
                                 base::Bind(&chromeos::StoreDisplayPrefs));
     }
   }
   return true;
 }
 
 system_display::DisplayMode GetDisplayMode(
     ash::DisplayManager* display_manager,
-    const ash::DisplayInfo& display_info,
-    const scoped_refptr<ash::ManagedDisplayMode>& display_mode) {
+    const display::ManagedDisplayInfo& display_info,
+    const scoped_refptr<display::ManagedDisplayMode>& display_mode) {
   system_display::DisplayMode result;
 
   bool is_internal = display::Display::HasInternalDisplay() &&
                      display::Display::InternalDisplayId() == display_info.id();
   gfx::Size size_dip = display_mode->GetSizeInDIP(is_internal);
   result.width = size_dip.width();
   result.height = size_dip.height();
   result.width_in_native_pixels = display_mode->size().width();
   result.height_in_native_pixels = display_mode->size().height();
   result.ui_scale = display_mode->ui_scale();
@@ skipping 125 matching lines @@
     const display::Display& display,
     system_display::DisplayUnitInfo* unit) {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   unit->name = display_manager->GetDisplayNameForId(display.id());
   if (display_manager->IsInMirrorMode()) {
     unit->mirroring_source_id =
         base::Int64ToString(display_manager->mirroring_display_id());
   }
 
-  const ash::DisplayInfo& display_info =
+  const display::ManagedDisplayInfo& display_info =
       display_manager->GetDisplayInfo(display.id());
   const float device_dpi = display_info.device_dpi();
   unit->dpi_x = device_dpi * display.size().width() /
                 display_info.bounds_in_native().width();
   unit->dpi_y = device_dpi * display.size().height() /
                 display_info.bounds_in_native().height();
 
   const gfx::Insets overscan_insets =
       display_manager->GetOverscanInsets(display.id());
   unit->overscan.left = overscan_insets.left();
   unit->overscan.top = overscan_insets.top();
   unit->overscan.right = overscan_insets.right();
   unit->overscan.bottom = overscan_insets.bottom();
 
-  for (const scoped_refptr<ash::ManagedDisplayMode>& display_mode :
+  for (const scoped_refptr<display::ManagedDisplayMode>& display_mode :
        display_info.display_modes()) {
     unit->modes.push_back(
         GetDisplayMode(display_manager, display_info, display_mode));
   }
 }
 
 void DisplayInfoProviderChromeOS::EnableUnifiedDesktop(bool enable) {
   ash::Shell::GetInstance()->display_manager()->SetUnifiedDesktopEnabled(
       enable);
 }
@@ skipping 104 matching lines @@
     return nullptr;
   return iter->second.get();
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions