Move DisplayLayout and DisplayLayoutBuilder From ash To ui/display

ash/display/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 <algorithm>
 #include <cmath>
 #include <set>
 #include <string>
@@ skipping 34 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace ash {
-typedef std::vector<gfx::Display> DisplayList;
 typedef std::vector<DisplayInfo> DisplayInfoList;
 
 namespace {
 
 // We need to keep this in order for unittests to tell if
 // the object in gfx::Screen::GetScreenByType is for shutdown.
 gfx::Screen* screen_for_shutdown = nullptr;
 
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
@@ skipping 45 matching lines @@
 
 gfx::Size GetMaxNativeSize(const DisplayInfo& info) {
   gfx::Size size;
   for (auto& mode : info.display_modes()) {
     if (mode.size.GetArea() > size.GetArea())
       size = mode.size;
   }
   return size;
 }
 
-gfx::Display* FindDisplayById(DisplayList* display_list, int64_t id) {
+gfx::Display* FindDisplayById(display::DisplayList* display_list, int64_t id) {
   auto iter = std::find_if(
       display_list->begin(), display_list->end(),
       [id](const gfx::Display& display) { return display.id() == id; });
   return &(*iter);
 }
 
 }  // namespace
 
 using std::string;
 using std::vector;
@@ skipping 72 matching lines @@
   float largest_device_scale_factor = 1.0f;
   for (const gfx::Display& display : active_display_list_) {
     const ash::DisplayInfo& info = display_info_[display.id()];
     largest_device_scale_factor = std::max(
         largest_device_scale_factor, info.GetEffectiveDeviceScaleFactor());
   }
   gfx::SetFontRenderParamsDeviceScaleFactor(largest_device_scale_factor);
 #endif  // OS_CHROMEOS
 }
 
-const DisplayLayout& DisplayManager::GetCurrentDisplayLayout() const {
+const display::DisplayLayout& DisplayManager::GetCurrentDisplayLayout() const {
   DCHECK_LE(2U, num_connected_displays());
   if (num_connected_displays() > 1) {
-    DisplayIdList list = GetCurrentDisplayIdList();
+    display::DisplayIdList list = GetCurrentDisplayIdList();
     return layout_store_->GetRegisteredDisplayLayout(list);
   }
   LOG(ERROR) << "DisplayLayout is requested for single display";
   // On release build, just fallback to default instead of blowing up.
-  static DisplayLayout layout;
+  static display::DisplayLayout layout;
   layout.primary_id = active_display_list_[0].id();
   return layout;
 }
 
-DisplayIdList DisplayManager::GetCurrentDisplayIdList() const {
+display::DisplayIdList DisplayManager::GetCurrentDisplayIdList() const {
   if (IsInUnifiedMode()) {
     return CreateDisplayIdList(software_mirroring_display_list_);
   } else if (IsInMirrorMode()) {
     if (software_mirroring_enabled()) {
       CHECK_EQ(2u, num_connected_displays());
       // This comment is to make it easy to distinguish the crash
       // between two checks.
       CHECK_EQ(1u, active_display_list_.size());
     }
     int64_t ids[] = {active_display_list_[0].id(), mirroring_display_id_};
     return ash::GenerateDisplayIdList(std::begin(ids), std::end(ids));
   } else {
     CHECK_LE(2u, active_display_list_.size());
     return CreateDisplayIdList(active_display_list_);
   }
 }
 
 void DisplayManager::SetLayoutForCurrentDisplays(
-    scoped_ptr<DisplayLayout> layout) {
+    scoped_ptr<display::DisplayLayout> layout) {
   if (GetNumDisplays() == 1)
     return;
-  const DisplayIdList list = GetCurrentDisplayIdList();
+  const display::DisplayIdList list = GetCurrentDisplayIdList();
 
-  DCHECK(DisplayLayout::Validate(list, *layout));
+  DCHECK(display::DisplayLayout::Validate(list, *layout));
 
-  const DisplayLayout& current_layout =
+  const display::DisplayLayout& current_layout =
       layout_store_->GetRegisteredDisplayLayout(list);
 
   if (layout->HasSamePlacementList(current_layout))
     return;
 
   layout_store_->RegisterLayoutForDisplayIdList(list, std::move(layout));
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
 
   // TODO(oshima): Call UpdateDisplays instead.
@@ skipping 343 matching lines @@
           display_info_[gfx::Display::InternalDisplayId()].GetRotation(
               gfx::Display::ROTATION_SOURCE_USER);
       display_info_[gfx::Display::InternalDisplayId()].SetRotation(
           user_rotation, gfx::Display::ROTATION_SOURCE_USER);
     }
   }
 
 #if defined(OS_CHROMEOS)
   if (!base::SysInfo::IsRunningOnChromeOS() &&
       new_display_info_list.size() > 1) {
-    DisplayIdList list = GenerateDisplayIdList(
+    display::DisplayIdList list = GenerateDisplayIdList(
         new_display_info_list.begin(), new_display_info_list.end(),
         [](const DisplayInfo& info) { return info.id(); });
 
-    const DisplayLayout& layout =
+    const display::DisplayLayout& layout =
         layout_store_->GetRegisteredDisplayLayout(list);
     // Mirror mode is set by DisplayConfigurator on the device.
     // Emulate it when running on linux desktop.
     if (layout.mirrored)
       SetMultiDisplayMode(MIRRORING);
   }
 #endif
 
   UpdateDisplaysWith(new_display_info_list);
 }
@@ skipping 15 matching lines @@
 #endif
 
   DisplayInfoList new_display_info_list = updated_display_info_list;
   std::sort(active_display_list_.begin(), active_display_list_.end(),
             DisplaySortFunctor());
   std::sort(new_display_info_list.begin(),
             new_display_info_list.end(),
             DisplayInfoSortFunctor());
 
   if (new_display_info_list.size() > 1) {
-    DisplayIdList list = GenerateDisplayIdList(
+    display::DisplayIdList list = GenerateDisplayIdList(
         new_display_info_list.begin(), new_display_info_list.end(),
         [](const DisplayInfo& info) { return info.id(); });
-    const DisplayLayout& layout =
+    const display::DisplayLayout& layout =
         layout_store_->GetRegisteredDisplayLayout(list);
     current_default_multi_display_mode_ =
         (layout.default_unified && unified_desktop_enabled_) ? UNIFIED
                                                              : EXTENDED;
   }
 
   if (multi_display_mode_ != MIRRORING)
     multi_display_mode_ = current_default_multi_display_mode_;
 
   CreateSoftwareMirroringDisplayInfo(&new_display_info_list);
 
   // Close the mirroring window if any here to avoid creating two compositor on
   // one display.
   if (delegate_)
     delegate_->CloseMirroringDisplayIfNotNecessary();
 
-  DisplayList new_displays;
-  DisplayList removed_displays;
+  display::DisplayList new_displays;
+  display::DisplayList removed_displays;
   std::map<size_t, uint32_t> display_changes;
   std::vector<size_t> added_display_indices;
 
-  DisplayList::iterator curr_iter = active_display_list_.begin();
+  display::DisplayList::iterator curr_iter = active_display_list_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   while (curr_iter != active_display_list_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (curr_iter == active_display_list_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
@@ skipping 154 matching lines @@
 }
 
 const gfx::Display& DisplayManager::GetDisplayAt(size_t index) const {
   DCHECK_LT(index, active_display_list_.size());
   return active_display_list_[index];
 }
 
 const gfx::Display& DisplayManager::GetPrimaryDisplayCandidate() const {
   if (GetNumDisplays() != 2)
     return active_display_list_[0];
-  const DisplayLayout& layout =
+  const display::DisplayLayout& layout =
       layout_store_->GetRegisteredDisplayLayout(GetCurrentDisplayIdList());
   return GetDisplayForId(layout.primary_id);
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return active_display_list_.size();
 }
 
 bool DisplayManager::IsActiveDisplayId(int64_t display_id) const {
   return std::find_if(active_display_list_.begin(), active_display_list_.end(),
@@ skipping 96 matching lines @@
   }
   num_connected_displays_ = new_display_info_list.size();
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
   UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!active_display_list_.empty());
   std::vector<DisplayInfo> new_display_info_list;
-  for (DisplayList::const_iterator iter = active_display_list_.begin();
+  for (display::DisplayList::const_iterator iter = active_display_list_.begin();
        iter != active_display_list_.end(); ++iter) {
     DisplayInfo display_info = GetDisplayInfo(iter->id());
     display_info.set_device_scale_factor(
         display_info.device_scale_factor() == 1.0f ? 2.0f : 1.0f);
     new_display_info_list.push_back(display_info);
   }
   AddMirrorDisplayInfoIfAny(&new_display_info_list);
   UpdateDisplaysWith(new_display_info_list);
 }
 
 #if defined(OS_CHROMEOS)
 void DisplayManager::SetSoftwareMirroring(bool enabled) {
   SetMultiDisplayMode(enabled ? MIRRORING
                               : current_default_multi_display_mode_);
 }
 
 bool DisplayManager::SoftwareMirroringEnabled() const {
   return software_mirroring_enabled();
 }
 #endif
 
 void DisplayManager::SetDefaultMultiDisplayModeForCurrentDisplays(
     MultiDisplayMode mode) {
   DCHECK_NE(MIRRORING, mode);
-  DisplayIdList list = GetCurrentDisplayIdList();
+  display::DisplayIdList list = GetCurrentDisplayIdList();
   layout_store_->UpdateMultiDisplayState(list, IsInMirrorMode(),
                                          mode == UNIFIED);
   ReconfigureDisplays();
 }
 
 void DisplayManager::SetMultiDisplayMode(MultiDisplayMode mode) {
   multi_display_mode_ = mode;
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
 }
@@ skipping 265 matching lines @@
 
   gfx::Display new_display(display_info.id());
   new_display.SetScaleAndBounds(
       1.0f, gfx::Rect(origin, gfx::ScaleToFlooredSize(
                                   display_info.size_in_pixel(), scale)));
   new_display.set_touch_support(display_info.touch_support());
   return new_display;
 }
 
 void DisplayManager::UpdateNonPrimaryDisplayBoundsForLayout(
-    DisplayList* display_list,
+    display::DisplayList* display_list,
     std::vector<size_t>* updated_indices) {
   if (display_list->size() == 1u)
     return;
 
-  const DisplayLayout& layout = layout_store_->GetRegisteredDisplayLayout(
-      CreateDisplayIdList(*display_list));
+  const display::DisplayLayout& layout =
+      layout_store_->GetRegisteredDisplayLayout(
+          CreateDisplayIdList(*display_list));
 
   // Ignore if a user has a old format (should be extremely rare)
   // and this will be replaced with DCHECK.
   if (layout.primary_id == gfx::Display::kInvalidDisplayID)
     return;
 
   std::vector<int64_t> ids;
   ApplyDisplayLayout(layout, display_list, &ids);
   for (int64_t display_id : ids) {
     DCHECK_NE(gfx::Display::kInvalidDisplayID, display_id);
     const auto iter = std::find_if(display_list->begin(), display_list->end(),
                                    [display_id](const gfx::Display& display) {
                                      return display.id() == display_id;
                                    });
     DCHECK(display_list->end() != iter);
     updated_indices->push_back(iter - display_list->begin());
   }
 }
 
 void DisplayManager::CreateMirrorWindowIfAny() {
   if (software_mirroring_display_list_.empty() || !delegate_)
     return;
   DisplayInfoList list;
   for (auto& display : software_mirroring_display_list_)
     list.push_back(GetDisplayInfo(display.id()));
   delegate_->CreateOrUpdateMirroringDisplay(list);
 }
 
-void DisplayManager::ApplyDisplayLayout(const DisplayLayout& layout,
-                                        DisplayList* display_list,
+void DisplayManager::ApplyDisplayLayout(const display::DisplayLayout& layout,
+                                        display::DisplayList* display_list,
                                         std::vector<int64_t>* updated_ids) {
   // Layout from primary, then dependent displays.
   std::set<int64_t> parents;
   parents.insert(layout.primary_id);
   while (parents.size()) {
     int64_t parent_id = *parents.begin();
     parents.erase(parent_id);
-    for (const DisplayPlacement& placement : layout.placement_list) {
+    for (const display::DisplayPlacement& placement : layout.placement_list) {
       if (placement.parent_display_id == parent_id) {
         if (ApplyDisplayPlacement(placement, display_list) && updated_ids)
           updated_ids->push_back(placement.display_id);
         parents.insert(placement.display_id);
       }
     }
   }
 }
 
-bool DisplayManager::ApplyDisplayPlacement(const DisplayPlacement& placement,
-                                           DisplayList* display_list) {
+bool DisplayManager::ApplyDisplayPlacement(
+    const display::DisplayPlacement& placement,
+    display::DisplayList* display_list) {
   const gfx::Display& parent_display =
       *FindDisplayById(display_list, placement.parent_display_id);
   DCHECK(parent_display.is_valid());
   gfx::Display* target_display =
       FindDisplayById(display_list, placement.display_id);
   DCHECK(target_display);
 
   const gfx::Rect& parent_bounds = parent_display.bounds();
   const gfx::Rect& target_bounds = target_display->bounds();
   gfx::Point new_target_origin = parent_bounds.origin();
 
-  DisplayPlacement::Position position = placement.position;
+  display::DisplayPlacement::Position position = placement.position;
 
   // Ignore the offset in case the target display doesn't share edges with
   // the parent display.
   int offset = placement.offset;
-  if (position == DisplayPlacement::TOP ||
-      position == DisplayPlacement::BOTTOM) {
+  if (position == display::DisplayPlacement::TOP ||
+      position == display::DisplayPlacement::BOTTOM) {
     offset = std::min(
         offset, parent_bounds.width() - kMinimumOverlapForInvalidOffset);
     offset = std::max(
         offset, -target_bounds.width() + kMinimumOverlapForInvalidOffset);
   } else {
     offset = std::min(
         offset, parent_bounds.height() - kMinimumOverlapForInvalidOffset);
     offset = std::max(
         offset, -target_bounds.height() + kMinimumOverlapForInvalidOffset);
   }
   switch (position) {
-    case DisplayPlacement::TOP:
+    case display::DisplayPlacement::TOP:
       new_target_origin.Offset(offset, -target_bounds.height());
       break;
-    case DisplayPlacement::RIGHT:
+    case display::DisplayPlacement::RIGHT:
       new_target_origin.Offset(parent_bounds.width(), offset);
       break;
-    case DisplayPlacement::BOTTOM:
+    case display::DisplayPlacement::BOTTOM:
       new_target_origin.Offset(offset, parent_bounds.height());
       break;
-    case DisplayPlacement::LEFT:
+    case display::DisplayPlacement::LEFT:
       new_target_origin.Offset(-target_bounds.width(), offset);
       break;
   }
 
   // This function may be called before the secondary display is
   // registered, in which case, the function should return true.
   gfx::Display* old_display = FindDisplayForId(placement.display_id);
   gfx::Rect old_bounds;
   if (old_display)
     old_bounds = old_display->bounds();
 
   gfx::Insets insets = target_display->GetWorkAreaInsets();
   target_display->set_bounds(
       gfx::Rect(new_target_origin, target_bounds.size()));
   target_display->UpdateWorkAreaFromInsets(insets);
 
   return old_bounds != target_display->bounds();
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash