Detect and fix overlapping displays

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 "ui/display/manager/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 190 matching lines @@
     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;
   layout.primary_id = active_display_list_[0].id();
   return layout;
 }
 
+const DisplayLayout& DisplayManager::GetCurrentResolvedDisplayLayout() const {
+  return current_resolved_layout_ ? *current_resolved_layout_
+                                  : GetCurrentDisplayLayout();
+}
+
 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());
     }
@@ skipping 18 matching lines @@
 
   if (layout->HasSamePlacementList(current_layout))
     return;
 
   layout_store_->RegisterLayoutForDisplayIdList(list, std::move(layout));
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
 
   // TODO(oshima): Call UpdateDisplays instead.
   std::vector<int64_t> updated_ids;
-  ApplyDisplayLayout(GetCurrentDisplayLayout(), &active_display_list_,
+  current_resolved_layout_ = GetCurrentDisplayLayout().Copy();
+  ApplyDisplayLayout(current_resolved_layout_.get(), &active_display_list_,
                      &updated_ids);
   for (int64_t id : updated_ids) {
     NotifyMetricsChanged(GetDisplayForId(id),
                          DisplayObserver::DISPLAY_METRIC_BOUNDS |
                              DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   }
 
   if (delegate_)
     delegate_->PostDisplayConfigurationChange(false);
 }
@@ skipping 1113 matching lines @@
   const 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 == kInvalidDisplayId)
     return;
 
   // display_list does not have translation set, so ApplyDisplayLayout cannot
   // provide accurate change information. We'll find the changes after the call.
-  ApplyDisplayLayout(layout, display_list, nullptr);
+  current_resolved_layout_ = layout.Copy();
+  ApplyDisplayLayout(current_resolved_layout_.get(), display_list, nullptr);
   size_t num_displays = display_list->size();
   for (size_t index = 0; index < num_displays; ++index) {
     const Display& display = (*display_list)[index];
     int64_t id = display.id();
     const Display* active_display = FindDisplayForId(id);
     if (!active_display || (active_display->bounds() != display.bounds()))
       updated_indices->push_back(index);
   }
 }
 
 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,
+void DisplayManager::ApplyDisplayLayout(DisplayLayout* layout,
                                         Displays* display_list,
                                         std::vector<int64_t>* updated_ids) {
-  layout.ApplyToDisplayList(display_list, updated_ids,
-                            kMinimumOverlapForInvalidOffset);
+  if (multi_display_mode_ == UNIFIED) {
+    // Applying the layout in unified mode doesn't make sense, since there's no
+    // layout.
+    return;
+  }
+
+  layout->ApplyToDisplayList(display_list, updated_ids,
+                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 void DisplayManager::NotifyMetricsChanged(const Display& display,
                                           uint32_t metrics) {
   for (auto& observer : observers_)
@@ skipping 19 matching lines @@
 }
 
 const Display& DisplayManager::GetSecondaryDisplay() const {
   CHECK_LE(2U, GetNumDisplays());
   return GetDisplayAt(0).id() == Screen::GetScreen()->GetPrimaryDisplay().id()
              ? GetDisplayAt(1)
              : GetDisplayAt(0);
 }
 
 }  // namespace display