Relocate display_manager from ash to ui

ui/display/manager/display_manager.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 "ash/display/display_manager.h"
+#include "ui/display/manager/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "ui/display/display_observer.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/manager/display_layout_store.h"
 #include "ui/display/manager/display_manager_utilities.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
-#if defined(USE_X11)
-#include "ui/base/x/x11_util.h"  // nogncheck
-#endif
-
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
-namespace ash {
+namespace display {
 
 namespace {
 
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 100;
 
 struct DisplaySortFunctor {
   bool operator()(const display::Display& a, const display::Display& b) {
     return display::CompareDisplayIds(a.id(), b.id());
@@ skipping 202 matching lines @@
   ApplyDisplayLayout(GetCurrentDisplayLayout(), &active_display_list_,
                      &updated_ids);
   for (int64_t id : updated_ids) {
     NotifyMetricsChanged(
         GetDisplayForId(id),
         display::DisplayObserver::DISPLAY_METRIC_BOUNDS |
             display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   }
 
   if (delegate_)
-    delegate_->PostDisplayConfigurationChange();
+    delegate_->PostDisplayConfigurationChange(false);
 }
 
 const display::Display& DisplayManager::GetDisplayForId(int64_t id) const {
   display::Display* display =
       const_cast<DisplayManager*>(this)->FindDisplayForId(id);
   return display ? *display : GetInvalidDisplay();
 }
 
 const display::Display& DisplayManager::FindDisplayContainingPoint(
     const gfx::Point& point_in_screen) const {
@@ skipping 188 matching lines @@
 }
 
 void DisplayManager::RegisterDisplayRotationProperties(
     bool rotation_lock,
     display::Display::Rotation rotation) {
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   registered_internal_display_rotation_lock_ = rotation_lock;
   registered_internal_display_rotation_ = rotation;
   if (delegate_)
-    delegate_->PostDisplayConfigurationChange();
+    delegate_->PostDisplayConfigurationChange(false);
 }
 
 scoped_refptr<display::ManagedDisplayMode>
 DisplayManager::GetSelectedModeForDisplayId(int64_t id) const {
   std::map<int64_t, scoped_refptr<display::ManagedDisplayMode>>::const_iterator
       iter = display_modes_.find(id);
   if (iter == display_modes_.end())
     return scoped_refptr<display::ManagedDisplayMode>();
   return iter->second;
 }
@@ skipping 20 matching lines @@
     delegate_->PreDisplayConfigurationChange(false);
   // Just sets color profile if it's not running on ChromeOS (like tests).
   if (!base::SysInfo::IsRunningOnChromeOS() ||
       delegate_->display_configurator()->SetColorCalibrationProfile(display_id,
                                                                     profile)) {
     display_info_[display_id].SetColorProfile(profile);
     UMA_HISTOGRAM_ENUMERATION("ChromeOS.Display.ColorProfile", profile,
                               ui::NUM_COLOR_PROFILES);
   }
   if (delegate_)
-    delegate_->PostDisplayConfigurationChange();
+    delegate_->PostDisplayConfigurationChange(false);
 #endif
 }
 
 void DisplayManager::OnNativeDisplaysChanged(
     const DisplayInfoList& updated_displays) {
   if (updated_displays.empty()) {
     VLOG(1) << "OnNativeDisplaysChanged(0): # of current displays="
             << active_display_list_.size();
     // If the device is booted without display, or chrome is started
     // without --ash-host-window-bounds on linux desktop, use the
@@ skipping 257 matching lines @@
       display_changes[updated_index] = metrics;
     }
   }
 
   active_display_list_ = new_displays;
   active_only_display_list_ = active_display_list_;
 
   RefreshFontParams();
   base::AutoReset<bool> resetter(&change_display_upon_host_resize_, false);
 
-  int active_display_list_size = active_display_list_.size();
+  size_t active_display_list_size = active_display_list_.size();
   is_updating_display_list_ = true;
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   active_display_list_.insert(active_display_list_.end(),
                               removed_displays.begin(), removed_displays.end());
 
   for (const auto& display : removed_displays)
     NotifyDisplayRemoved(display);
 
   for (size_t index : added_display_indices)
@@ skipping 28 matching lines @@
         metrics |= (display::DisplayObserver::DISPLAY_METRIC_BOUNDS |
                     display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
       }
       if (primary.device_scale_factor() != old_primary.device_scale_factor())
         metrics |= display::DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR;
 
       NotifyMetricsChanged(primary, metrics);
     }
   }
 
+  bool must_clear_window = false;
+#if defined(USE_X11) && defined(OS_CHROMEOS)
+  must_clear_window =
+      !display_changes.empty() && base::SysInfo::IsRunningOnChromeOS();
+#endif
+
   if (delegate_)
-    delegate_->PostDisplayConfigurationChange();
-
-#if defined(USE_X11) && defined(OS_CHROMEOS)
-  if (!display_changes.empty() && base::SysInfo::IsRunningOnChromeOS())
-    ui::ClearX11DefaultRootWindow();
-#endif
+    delegate_->PostDisplayConfigurationChange(must_clear_window);
 
   // Create the mirroring window asynchronously after all displays
   // are added so that it can mirror the display newly added. This can
   // happen when switching from dock mode to software mirror mode.
   CreateMirrorWindowAsyncIfAny();
 }
 
 const display::Display& DisplayManager::GetDisplayAt(size_t index) const {
   DCHECK_LT(index, active_display_list_.size());
   return active_display_list_[index];
@@ skipping 560 matching lines @@
 }
 
 const display::Display& DisplayManager::GetSecondaryDisplay() const {
   CHECK_LE(2U, GetNumDisplays());
   return GetDisplayAt(0).id() ==
                  display::Screen::GetScreen()->GetPrimaryDisplay().id()
              ? GetDisplayAt(1)
              : GetDisplayAt(0);
 }
 
-}  // namespace ash
+}  // namespace display