Use list instead of pair to represent the set of displays.

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 190 matching lines @@
         largest_device_scale_factor, info.GetEffectiveDeviceScaleFactor());
   }
   gfx::SetFontRenderParamsDeviceScaleFactor(largest_device_scale_factor);
 #endif  // OS_CHROMEOS
 }
 
 DisplayLayout DisplayManager::GetCurrentDisplayLayout() {
   DCHECK_LE(2U, num_connected_displays());
   // Invert if the primary was swapped.
   if (num_connected_displays() == 2) {
-    DisplayIdPair pair = GetCurrentDisplayIdPair();
-    return layout_store_->ComputeDisplayLayoutForDisplayIdPair(pair);
+    DisplayIdList list = GetCurrentDisplayIdList();
+    return layout_store_->ComputeDisplayLayoutForDisplayIdList(list);
   } else if (num_connected_displays() > 2) {
     // Return fixed horizontal layout for >= 3 displays.
     DisplayLayout layout(DisplayLayout::RIGHT, 0);
     return layout;
   }
   NOTREACHED() << "DisplayLayout is requested for single display";
   // On release build, just fallback to default instead of blowing up.
   DisplayLayout layout =
       layout_store_->default_display_layout();
   layout.primary_id = active_display_list_[0].id();
   return layout;
 }
 
-DisplayIdPair DisplayManager::GetCurrentDisplayIdPair() const {
+DisplayIdList DisplayManager::GetCurrentDisplayIdList() const {
   if (IsInUnifiedMode()) {
-    return CreateDisplayIdPair(software_mirroring_display_list_[0].id(),
+    return CreateDisplayIdList(software_mirroring_display_list_[0].id(),
                                software_mirroring_display_list_[1].id());
   } 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());
     }
-    return CreateDisplayIdPair(active_display_list_[0].id(),
+    return CreateDisplayIdList(active_display_list_[0].id(),
                                mirroring_display_id_);
   } else {
     CHECK_LE(2u, active_display_list_.size());
-    return CreateDisplayIdPair(active_display_list_[0].id(),
+    return CreateDisplayIdList(active_display_list_[0].id(),
                                active_display_list_[1].id());
   }
 }
 
 void DisplayManager::SetLayoutForCurrentDisplays(
     const DisplayLayout& layout_relative_to_primary) {
   if (GetNumDisplays() != 2)
     return;
   const gfx::Display& primary = screen_->GetPrimaryDisplay();
-  const DisplayIdPair pair = GetCurrentDisplayIdPair();
+  const DisplayIdList list = GetCurrentDisplayIdList();
   // Invert if the primary was swapped.
-  DisplayLayout to_set = pair.first == primary.id() ?
-      layout_relative_to_primary : layout_relative_to_primary.Invert();
+  DisplayLayout to_set = list[0] == primary.id()
+                             ? layout_relative_to_primary
+                             : layout_relative_to_primary.Invert();
 
   DisplayLayout current_layout =
-      layout_store_->GetRegisteredDisplayLayout(pair);
+      layout_store_->GetRegisteredDisplayLayout(list);
   if (to_set.position != current_layout.position ||
       to_set.offset != current_layout.offset) {
     to_set.primary_id = primary.id();
-    layout_store_->RegisterLayoutForDisplayIdPair(
-        pair.first, pair.second, to_set);
+    layout_store_->RegisterLayoutForDisplayIdList(list[0], list[1], to_set);
     if (delegate_)
       delegate_->PreDisplayConfigurationChange(false);
     // PreDisplayConfigurationChange(false);
     // TODO(oshima): Call UpdateDisplays instead.
     const DisplayLayout layout = GetCurrentDisplayLayout();
     UpdateDisplayBoundsForLayout(
         layout, primary,
         FindDisplayForId(ScreenUtil::GetSecondaryDisplay().id()));
 
     // Primary's bounds stay the same. Just notify bounds change
@@ skipping 339 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) {
-    DisplayIdPair pair = CreateDisplayIdPair(new_display_info_list[0].id(),
+    DisplayIdList list = CreateDisplayIdList(new_display_info_list[0].id(),
                                              new_display_info_list[1].id());
-    DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(pair);
+    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 14 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) {
-    DisplayIdPair pair = CreateDisplayIdPair(new_display_info_list[0].id(),
+    DisplayIdList list = CreateDisplayIdList(new_display_info_list[0].id(),
                                              new_display_info_list[1].id());
-    DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(pair);
+    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);
 
@@ skipping 179 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];
-  DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(
-      GetCurrentDisplayIdPair());
+  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(),
                       [display_id](const gfx::Display& display) {
@@ skipping 119 matching lines @@
 }
 
 bool DisplayManager::SoftwareMirroringEnabled() const {
   return software_mirroring_enabled();
 }
 #endif
 
 void DisplayManager::SetDefaultMultiDisplayModeForCurrentDisplays(
     MultiDisplayMode mode) {
   DCHECK_NE(MIRRORING, mode);
-  DisplayIdPair pair = GetCurrentDisplayIdPair();
-  layout_store_->UpdateMultiDisplayState(pair, IsInMirrorMode(),
+  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 286 matching lines @@
       gfx::Point origin = gfx::Point(x_offset, 0);
       gfx::Insets insets = display.GetWorkAreaInsets();
       display.set_bounds(gfx::Rect(origin, bounds.size()));
       display.UpdateWorkAreaFromInsets(insets);
       x_offset += bounds.width();
       updated_indices->push_back(i);
     }
     return true;
   }
 
-  DisplayLayout layout = layout_store_->ComputeDisplayLayoutForDisplayIdPair(
-      CreateDisplayIdPair(displays->at(0).id(), displays->at(1).id()));
+  DisplayLayout layout = layout_store_->ComputeDisplayLayoutForDisplayIdList(
+      CreateDisplayIdList(displays->at(0).id(), displays->at(1).id()));
 
   // 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) {
     size_t primary_index, secondary_index;
     if (displays->at(0).id() == layout.primary_id) {
       primary_index = 0;
       secondary_index = 1;
     } else {
       primary_index = 1;
@@ skipping 67 matching lines @@
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash