Move ash::DisplayInfo to ui

ash/display/display_change_observer_chromeos.cc

 // Copyright 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/display_change_observer_chromeos.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
@@ skipping 57 matching lines @@
       if (display::Display::HasInternalDisplay())
         DCHECK_EQ(display::Display::InternalDisplayId(), state->display_id());
       display::Display::SetInternalDisplayId(state->display_id());
     }
   }
 }
 
 }  // namespace
 
 // static
-DisplayInfo::ManagedDisplayModeList
+ui::ManagedDisplayInfo::ManagedDisplayModeList
 DisplayChangeObserver::GetInternalManagedDisplayModeList(
-    const DisplayInfo& display_info,
+    const ui::ManagedDisplayInfo& display_info,
     const ui::DisplaySnapshot& output) {
   const ui::DisplayMode* ui_native_mode = output.native_mode();
-  scoped_refptr<ManagedDisplayMode> native_mode = new ManagedDisplayMode(
-      ui_native_mode->size(), ui_native_mode->refresh_rate(),
-      ui_native_mode->is_interlaced(), true, 1.0,
-      display_info.device_scale_factor());
+  scoped_refptr<ui::ManagedDisplayMode> native_mode =
+      new ui::ManagedDisplayMode(ui_native_mode->size(),
+                                 ui_native_mode->refresh_rate(),
+                                 ui_native_mode->is_interlaced(), true, 1.0,
+                                 display_info.device_scale_factor());
 
   return CreateInternalManagedDisplayModeList(native_mode);
 }
 
 // static
-DisplayInfo::ManagedDisplayModeList
+ui::ManagedDisplayInfo::ManagedDisplayModeList
 DisplayChangeObserver::GetExternalManagedDisplayModeList(
     const ui::DisplaySnapshot& output) {
   using DisplayModeMap =
-      std::map<std::pair<int, int>, scoped_refptr<ManagedDisplayMode>>;
+      std::map<std::pair<int, int>, scoped_refptr<ui::ManagedDisplayMode>>;
   DisplayModeMap display_mode_map;
 
-  scoped_refptr<ManagedDisplayMode> native_mode = new ManagedDisplayMode();
+  scoped_refptr<ui::ManagedDisplayMode> native_mode =
+      new ui::ManagedDisplayMode();
   for (const auto& mode_info : output.modes()) {
     const std::pair<int, int> size(mode_info->size().width(),
                                    mode_info->size().height());
-    scoped_refptr<ManagedDisplayMode> display_mode = new ManagedDisplayMode(
-        mode_info->size(), mode_info->refresh_rate(),
-        mode_info->is_interlaced(), output.native_mode() == mode_info.get(),
-        1.0, 1.0);
+    scoped_refptr<ui::ManagedDisplayMode> display_mode =
+        new ui::ManagedDisplayMode(mode_info->size(), mode_info->refresh_rate(),
+                                   mode_info->is_interlaced(),
+                                   output.native_mode() == mode_info.get(), 1.0,
+                                   1.0);
     if (display_mode->native())
       native_mode = display_mode;
 
     // Add the display mode if it isn't already present and override interlaced
     // display modes with non-interlaced ones.
     DisplayModeMap::iterator display_mode_it = display_mode_map.find(size);
     if (display_mode_it == display_mode_map.end())
       display_mode_map.insert(std::make_pair(size, display_mode));
     else if (display_mode_it->second->is_interlaced() &&
              !display_mode->is_interlaced())
       display_mode_it->second = std::move(display_mode);
   }
 
-  DisplayInfo::ManagedDisplayModeList display_mode_list;
+  ui::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list;
   for (const auto& display_mode_pair : display_mode_map)
     display_mode_list.push_back(std::move(display_mode_pair.second));
 
   if (output.native_mode()) {
     const std::pair<int, int> size(native_mode->size().width(),
                                    native_mode->size().height());
     DisplayModeMap::iterator it = display_mode_map.find(size);
     DCHECK(it != display_mode_map.end())
         << "Native mode must be part of the mode list.";
 
     // If the native mode was replaced re-add it.
     if (!it->second->native())
       display_mode_list.push_back(native_mode);
   }
 
   if (native_mode->size().width() >= kMinimumWidthFor4K) {
     for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k); ++i) {
-      scoped_refptr<ManagedDisplayMode> mode = new ManagedDisplayMode(
+      scoped_refptr<ui::ManagedDisplayMode> mode = new ui::ManagedDisplayMode(
           native_mode->size(), native_mode->refresh_rate(),
           native_mode->is_interlaced(), false /* native */,
           native_mode->ui_scale(), kAdditionalDeviceScaleFactorsFor4k[i]);
       display_mode_list.push_back(mode);
     }
   }
 
   return display_mode_list;
 }
 
@@ skipping 21 matching lines @@
   const display::DisplayLayout& layout = Shell::GetInstance()
                                              ->display_manager()
                                              ->layout_store()
                                              ->GetRegisteredDisplayLayout(list);
   return layout.mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR
                          : ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
 }
 
 bool DisplayChangeObserver::GetResolutionForDisplayId(int64_t display_id,
                                                       gfx::Size* size) const {
-  scoped_refptr<ManagedDisplayMode> mode =
+  scoped_refptr<ui::ManagedDisplayMode> mode =
       Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
           display_id);
   if (!mode)
     return false;
   *size = mode->size();
   return true;
 }
 
 void DisplayChangeObserver::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& display_states) {
   UpdateInternalDisplayId(display_states);
 
-  std::vector<DisplayInfo> displays;
+  std::vector<ui::ManagedDisplayInfo> displays;
   std::set<int64_t> ids;
   for (const ui::DisplaySnapshot* state : display_states) {
     const ui::DisplayMode* mode_info = state->current_mode();
     if (!mode_info)
       continue;
 
     float device_scale_factor = 1.0f;
     // Sets dpi only if the screen size is not blacklisted.
     float dpi = ui::IsDisplaySizeBlackListed(state->physical_size())
                     ? 0
                     : kInchInMm * mode_info->size().width() /
                           state->physical_size().width();
     if (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) {
       if (dpi)
         device_scale_factor = FindDeviceScaleFactor(dpi);
     } else {
-      scoped_refptr<ManagedDisplayMode> mode =
+      scoped_refptr<ui::ManagedDisplayMode> mode =
           Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
               state->display_id());
       if (mode) {
         device_scale_factor = mode->device_scale_factor();
       } else {
         // For monitors that are 40 inches and 4K or above, set
         // |device_scale_factor| to 2x. For margin purposes, 100 is subtracted
         // from the value of |k2xThreshouldSizeSquaredFor4KInMm|
         const int k2xThreshouldSizeSquaredFor4KInMm =
             (40 * 40 * kInchInMm * kInchInMm) - 100;
@@ skipping 21 matching lines @@
         name = state->display_name();
     }
 
     if (name.empty())
       name = l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
     bool has_overscan = state->has_overscan();
     int64_t id = state->display_id();
     ids.insert(id);
 
-    displays.push_back(DisplayInfo(id, name, has_overscan));
-    DisplayInfo& new_info = displays.back();
+    displays.push_back(ui::ManagedDisplayInfo(id, name, has_overscan));
+    ui::ManagedDisplayInfo& new_info = displays.back();
     new_info.set_sys_path(state->sys_path());
     new_info.set_device_scale_factor(device_scale_factor);
     new_info.SetBounds(display_bounds);
     new_info.set_native(true);
     new_info.set_is_aspect_preserving_scaling(
         state->is_aspect_preserving_scaling());
     if (dpi)
       new_info.set_device_dpi(dpi);
 
-    DisplayInfo::ManagedDisplayModeList display_modes =
+    ui::ManagedDisplayInfo::ManagedDisplayModeList display_modes =
         (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
             ? GetInternalManagedDisplayModeList(new_info, *state)
             : GetExternalManagedDisplayModeList(*state);
     new_info.SetManagedDisplayModes(display_modes);
 
     new_info.set_available_color_profiles(
         Shell::GetInstance()
             ->display_configurator()
             ->GetAvailableColorCalibrationProfiles(id));
     new_info.set_maximum_cursor_size(state->maximum_cursor_size());
@@ skipping 37 matching lines @@
   }
   return 1.0f;
 }
 
 void DisplayChangeObserver::OnTouchscreenDeviceConfigurationChanged() {
   OnDisplayModeChanged(
       Shell::GetInstance()->display_configurator()->cached_displays());
 }
 
 }  // namespace ash