Move DisplayChangeObserver + tests from ash to ui.

ui/display/manager/chromeos/display_change_observer.cc

Index: ui/display/manager/chromeos/display_change_observer.cc
diff --git a/ash/display/display_change_observer_chromeos.cc b/ui/display/manager/chromeos/display_change_observer.cc
similarity index 79%
rename from ash/display/display_change_observer_chromeos.cc
rename to ui/display/manager/chromeos/display_change_observer.cc
index b25293868873ca3656c472a39d2be5792cfa2c65..150db3892bbbf6c3e0349c5cfe5acfb2dd5aa596 100644
--- a/ash/display/display_change_observer_chromeos.cc
+++ b/ui/display/manager/chromeos/display_change_observer.cc
@@ -2,7 +2,7 @@
 // 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 "ui/display/manager/chromeos/display_change_observer.h"
 
 #include <algorithm>
 #include <map>
@@ -27,7 +27,7 @@
 #include "ui/events/devices/touchscreen_device.h"
 #include "ui/strings/grit/ui_strings.h"
 
-namespace ash {
+namespace display {
 
 using ui::DisplayConfigurator;
 
@@ -60,9 +60,9 @@ void UpdateInternalDisplayId(
     const ui::DisplayConfigurator::DisplayStateList& display_states) {
   for (auto* state : display_states) {
     if (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) {
-      if (display::Display::HasInternalDisplay())
-        DCHECK_EQ(display::Display::InternalDisplayId(), state->display_id());
-      display::Display::SetInternalDisplayId(state->display_id());
+      if (Display::HasInternalDisplay())
+        DCHECK_EQ(Display::InternalDisplayId(), state->display_id());
+      Display::SetInternalDisplayId(state->display_id());
     }
   }
 }
@@ -70,38 +70,35 @@ void UpdateInternalDisplayId(
 }  // namespace
 
 // static
-display::ManagedDisplayInfo::ManagedDisplayModeList
+ManagedDisplayInfo::ManagedDisplayModeList
 DisplayChangeObserver::GetInternalManagedDisplayModeList(
-    const display::ManagedDisplayInfo& display_info,
+    const ManagedDisplayInfo& display_info,
     const ui::DisplaySnapshot& output) {
   const ui::DisplayMode* ui_native_mode = output.native_mode();
-  scoped_refptr<display::ManagedDisplayMode> native_mode =
-      new display::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<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());
 
-  return display::CreateInternalManagedDisplayModeList(native_mode);
+  return CreateInternalManagedDisplayModeList(native_mode);
 }
 
 // static
-display::ManagedDisplayInfo::ManagedDisplayModeList
+ManagedDisplayInfo::ManagedDisplayModeList
 DisplayChangeObserver::GetExternalManagedDisplayModeList(
     const ui::DisplaySnapshot& output) {
   using DisplayModeMap =
-      std::map<std::pair<int, int>, scoped_refptr<display::ManagedDisplayMode>>;
+      std::map<std::pair<int, int>, scoped_refptr<ManagedDisplayMode>>;
   DisplayModeMap display_mode_map;
 
-  scoped_refptr<display::ManagedDisplayMode> native_mode =
-      new display::ManagedDisplayMode();
+  scoped_refptr<ManagedDisplayMode> native_mode = new ManagedDisplayMode();
   for (const auto& mode_info : output.modes()) {
     const std::pair<int, int> size(mode_info->size().width(),
                                    mode_info->size().height());
-    scoped_refptr<display::ManagedDisplayMode> display_mode =
-        new display::ManagedDisplayMode(
-            mode_info->size(), mode_info->refresh_rate(),
-            mode_info->is_interlaced(), output.native_mode() == mode_info.get(),
-            1.0, 1.0);
+    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);
     if (display_mode->native())
       native_mode = display_mode;
 
@@ -115,7 +112,7 @@ DisplayChangeObserver::GetExternalManagedDisplayModeList(
       display_mode_it->second = std::move(display_mode);
   }
 
-  display::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list;
+  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));
 
@@ -133,11 +130,10 @@ DisplayChangeObserver::GetExternalManagedDisplayModeList(
 
   if (native_mode->size().width() >= kMinimumWidthFor4K) {
     for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k); ++i) {
-      scoped_refptr<display::ManagedDisplayMode> mode =
-          new display::ManagedDisplayMode(
-              native_mode->size(), native_mode->refresh_rate(),
-              native_mode->is_interlaced(), false /* native */,
-              native_mode->ui_scale(), kAdditionalDeviceScaleFactorsFor4k[i]);
+      scoped_refptr<ManagedDisplayMode> mode = new 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);
     }
   }
@@ -162,13 +158,13 @@ ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds(
   UpdateInternalDisplayId(display_states);
   if (display_states.size() == 1)
     return ui::MULTIPLE_DISPLAY_STATE_SINGLE;
-  display::DisplayIdList list = display::GenerateDisplayIdList(
-      display_states.begin(), display_states.end(),
-      [](const ui::DisplaySnapshot* display_state) {
-        return display_state->display_id();
-      });
+  DisplayIdList list =
+      GenerateDisplayIdList(display_states.begin(), display_states.end(),
+                            [](const ui::DisplaySnapshot* display_state) {
+                              return display_state->display_id();
+                            });
 
-  const display::DisplayLayout& layout =
+  const DisplayLayout& layout =
       display_manager_->layout_store()->GetRegisteredDisplayLayout(list);
   return layout.mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR
                          : ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
@@ -176,7 +172,7 @@ ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds(
 
 bool DisplayChangeObserver::GetResolutionForDisplayId(int64_t display_id,
                                                       gfx::Size* size) const {
-  scoped_refptr<display::ManagedDisplayMode> mode =
+  scoped_refptr<ManagedDisplayMode> mode =
       display_manager_->GetSelectedModeForDisplayId(display_id);
   if (!mode)
     return false;
@@ -188,7 +184,7 @@ void DisplayChangeObserver::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& display_states) {
   UpdateInternalDisplayId(display_states);
 
-  std::vector<display::ManagedDisplayInfo> displays;
+  std::vector<ManagedDisplayInfo> displays;
   std::set<int64_t> ids;
   for (const ui::DisplaySnapshot* state : display_states) {
     const ui::DisplayMode* mode_info = state->current_mode();
@@ -197,7 +193,7 @@ void DisplayChangeObserver::OnDisplayModeChanged(
 
     float device_scale_factor = 1.0f;
     // Sets dpi only if the screen size is not blacklisted.
-    float dpi = display::IsDisplaySizeBlackListed(state->physical_size())
+    float dpi = IsDisplaySizeBlackListed(state->physical_size())
                     ? 0
                     : kInchInMm * mode_info->size().width() /
                           state->physical_size().width();
@@ -205,7 +201,7 @@ void DisplayChangeObserver::OnDisplayModeChanged(
       if (dpi)
         device_scale_factor = FindDeviceScaleFactor(dpi);
     } else {
-      scoped_refptr<display::ManagedDisplayMode> mode =
+      scoped_refptr<ManagedDisplayMode> mode =
           display_manager_->GetSelectedModeForDisplayId(state->display_id());
       if (mode) {
         device_scale_factor = mode->device_scale_factor();
@@ -246,8 +242,8 @@ void DisplayChangeObserver::OnDisplayModeChanged(
     int64_t id = state->display_id();
     ids.insert(id);
 
-    displays.push_back(display::ManagedDisplayInfo(id, name, has_overscan));
-    display::ManagedDisplayInfo& new_info = displays.back();
+    displays.push_back(ManagedDisplayInfo(id, name, has_overscan));
+    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);
@@ -257,7 +253,7 @@ void DisplayChangeObserver::OnDisplayModeChanged(
     if (dpi)
       new_info.set_device_dpi(dpi);
 
-    display::ManagedDisplayInfo::ManagedDisplayModeList display_modes =
+    ManagedDisplayInfo::ManagedDisplayModeList display_modes =
         (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
             ? GetInternalManagedDisplayModeList(new_info, *state)
             : GetExternalManagedDisplayModeList(*state);
@@ -268,7 +264,7 @@ void DisplayChangeObserver::OnDisplayModeChanged(
     new_info.set_maximum_cursor_size(state->maximum_cursor_size());
   }
 
-  display::AssociateTouchscreens(
+  AssociateTouchscreens(
       &displays,
       ui::InputDeviceManager::GetInstance()->GetTouchscreenDevices());
   display_manager_->OnNativeDisplaysChanged(displays);
@@ -304,4 +300,4 @@ float DisplayChangeObserver::FindDeviceScaleFactor(float dpi) {
   return 1.0f;
 }
 
-}  // namespace ash
+}  // namespace display