Move ash::DisplayInfo to ui

chrome/browser/ui/webui/options/chromeos/display_options_handler.cc

 // Copyright (c) 2012 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/ui/webui/options/chromeos/display_options_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 103 matching lines @@
               const std::string& field,
               float* result) {
   double double_result = 0;
   if (dict->GetDouble(field, &double_result)) {
     *result = static_cast<float>(double_result);
     return true;
   }
   return false;
 }
 
-scoped_refptr<ash::ManagedDisplayMode> ConvertValueToManagedDisplayMode(
+scoped_refptr<ui::ManagedDisplayMode> ConvertValueToManagedDisplayMode(
     const base::DictionaryValue* dict) {
-  scoped_refptr<ash::ManagedDisplayMode> mode;
+  scoped_refptr<ui::ManagedDisplayMode> mode;
 
   gfx::Size size;
   size.set_width(GetIntOrDouble(dict, "originalWidth"));
   size.set_height(GetIntOrDouble(dict, "originalHeight"));
 
   if (size.IsEmpty()) {
     LOG(ERROR) << "missing width or height.";
     return mode;
   }
 
   float refresh_rate, ui_scale, device_scale_factor;
   if (!GetFloat(dict, "refreshRate", &refresh_rate)) {
     LOG(ERROR) << "missing refreshRate.";
     return mode;
   }
   if (!GetFloat(dict, "scale", &ui_scale)) {
     LOG(ERROR) << "missing ui-scale.";
     return mode;
   }
   if (!GetFloat(dict, "deviceScaleFactor", &device_scale_factor)) {
     LOG(ERROR) << "missing deviceScaleFactor.";
     return mode;
   }
 
   // Used to select the actual mode.
-  mode = new ash::ManagedDisplayMode(size, refresh_rate, false /* interlaced */,
-                                     false /* native */, ui_scale,
-                                     device_scale_factor);
+  mode = new ui::ManagedDisplayMode(size, refresh_rate, false /* interlaced */,
+                                    false /* native */, ui_scale,
+                                    device_scale_factor);
   return mode;
 }
 
 base::DictionaryValue* ConvertDisplayModeToValue(
     int64_t display_id,
-    const scoped_refptr<ash::ManagedDisplayMode>& mode) {
+    const scoped_refptr<ui::ManagedDisplayMode>& mode) {
   bool is_internal = display::Display::HasInternalDisplay() &&
                      display::Display::InternalDisplayId() == display_id;
   base::DictionaryValue* result = new base::DictionaryValue();
   gfx::Size size_dip = mode->GetSizeInDIP(is_internal);
   result->SetInteger("width", size_dip.width());
   result->SetInteger("height", size_dip.height());
   result->SetInteger("originalWidth", mode->size().width());
   result->SetInteger("originalHeight", mode->size().height());
   result->SetDouble("deviceScaleFactor", mode->device_scale_factor());
   result->SetDouble("scale", mode->ui_scale());
@@ skipping 141 matching lines @@
     display_mode = ash::DisplayManager::MIRRORING;
   else if (display_manager->IsInUnifiedMode())
     display_mode = ash::DisplayManager::UNIFIED;
   else
     display_mode = ash::DisplayManager::EXTENDED;
   base::FundamentalValue mode(static_cast<int>(display_mode));
 
   int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   std::unique_ptr<base::ListValue> js_displays(new base::ListValue);
   for (const display::Display& display : displays) {
-    const ash::DisplayInfo& display_info =
+    const ui::ManagedDisplayInfo& display_info =
         display_manager->GetDisplayInfo(display.id());
     base::DictionaryValue* js_display = new base::DictionaryValue();
     js_display->SetString("id", base::Int64ToString(display.id()));
     js_display->SetString("name",
                           display_manager->GetDisplayNameForId(display.id()));
     base::DictionaryValue* display_bounds =
         ConvertBoundsToValue(display.bounds());
     js_display->Set("bounds", display_bounds);
     js_display->SetBoolean("isPrimary", display.id() == primary_id);
     js_display->SetBoolean("isInternal", display.IsInternal());
     js_display->SetInteger("rotation", display.RotationAsDegree());
 
     base::ListValue* js_resolutions = new base::ListValue();
-    for (const scoped_refptr<ash::ManagedDisplayMode>& display_mode :
+    for (const scoped_refptr<ui::ManagedDisplayMode>& display_mode :
          display_info.display_modes()) {
       js_resolutions->Append(
           ConvertDisplayModeToValue(display.id(), display_mode));
     }
     js_display->Set("resolutions", js_resolutions);
 
     js_display->SetInteger("colorProfileId", display_info.color_profile());
     base::ListValue* available_color_profiles = new base::ListValue();
     for (const auto& color_profile : display_info.available_color_profiles()) {
       const base::string16 profile_name = GetColorProfileName(color_profile);
@@ skipping 124 matching lines @@
   int64_t display_id = GetDisplayIdFromArgs(args);
   if (display_id == display::Display::kInvalidDisplayID)
     return;
 
   const base::DictionaryValue* mode_data = nullptr;
   if (!args->GetDictionary(1, &mode_data)) {
     LOG(ERROR) << "Failed to get mode data";
     return;
   }
 
-  scoped_refptr<ash::ManagedDisplayMode> mode =
+  scoped_refptr<ui::ManagedDisplayMode> mode =
       ConvertValueToManagedDisplayMode(mode_data);
   if (!mode)
     return;
 
   content::RecordAction(
       base::UserMetricsAction("Options_DisplaySetResolution"));
   ash::DisplayManager* display_manager = GetDisplayManager();
-  scoped_refptr<ash::ManagedDisplayMode> current_mode =
+  scoped_refptr<ui::ManagedDisplayMode> current_mode =
       display_manager->GetActiveModeForDisplayId(display_id);
   if (!display_manager->SetDisplayMode(display_id, mode)) {
     LOG(ERROR) << "Unable to set display mode for: " << display_id
                << " Mode: " << *mode_data;
     return;
   }
   if (display::Display::IsInternalDisplayId(display_id))
     return;
   // For external displays, show a notification confirming the resolution
   // change.
@@ skipping 70 matching lines @@
   bool enable = false;
   if (!args->GetBoolean(0, &enable))
     NOTREACHED();
 
   GetDisplayManager()->SetDefaultMultiDisplayModeForCurrentDisplays(
       enable ? ash::DisplayManager::UNIFIED : ash::DisplayManager::EXTENDED);
 }
 
 }  // namespace options
 }  // namespace chromeos