Chrome OS: Ash support for >=3 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 260 matching lines @@
 
 bool DisplayManager::HasInternalDisplay() const {
   return gfx::Display::InternalDisplayId() != gfx::Display::kInvalidDisplayID;
 }
 
 bool DisplayManager::IsInternalDisplayId(int64 id) const {
   return gfx::Display::InternalDisplayId() == id;
 }
 
 DisplayLayout DisplayManager::GetCurrentDisplayLayout() {
-  DCHECK_EQ(2U, num_connected_displays());
+  DCHECK_LE(2U, num_connected_displays());
   // Invert if the primary was swapped.
-  if (num_connected_displays() > 1) {
+  if (num_connected_displays() == 2) {
     DisplayIdPair pair = GetCurrentDisplayIdPair();
     return layout_store_->ComputeDisplayLayoutForDisplayIdPair(pair);
+  } 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 = displays_[0].id();
   return layout;
 }
 
 DisplayIdPair DisplayManager::GetCurrentDisplayIdPair() const {
   if (IsMirrored()) {
     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, displays_.size());
     }
     return std::make_pair(displays_[0].id(), mirrored_display_id_);
   } else {
-    CHECK_GE(2u, displays_.size());
+    CHECK_LE(2u, displays_.size());
     int64 id_at_zero = displays_[0].id();
     if (id_at_zero == gfx::Display::InternalDisplayId() ||
         id_at_zero == first_display_id()) {
       return std::make_pair(id_at_zero, displays_[1].id());
     } else {
       return std::make_pair(displays_[1].id(), id_at_zero);
     }
   }
 }
 
 void DisplayManager::SetLayoutForCurrentDisplays(
     const DisplayLayout& layout_relative_to_primary) {
-  DCHECK_EQ(2U, GetNumDisplays());
-  if (GetNumDisplays() < 2)
+  if (GetNumDisplays() != 2)
     return;
   const gfx::Display& primary = screen_->GetPrimaryDisplay();
   const DisplayIdPair pair = GetCurrentDisplayIdPair();
   // Invert if the primary was swapped.
   DisplayLayout to_set = pair.first == primary.id() ?
       layout_relative_to_primary : layout_relative_to_primary.Invert();
 
   DisplayLayout current_layout =
       layout_store_->GetRegisteredDisplayLayout(pair);
   if (to_set.position != current_layout.position ||
@@ skipping 530 matching lines @@
     // is possible there is no need to update |displays_| and we early out
     // here. But we still want to run the PostDisplayConfigurationChange()
     // cause there are some clients need to act on this, e.g.
     // TouchTransformerController needs to adjust the TouchTransformer when
     // switching from dual displays to single display.
     if (delegate_)
       delegate_->PostDisplayConfigurationChange();
     return;
   }
 
-  size_t updated_index;
-  if (UpdateSecondaryDisplayBoundsForLayout(&new_displays, &updated_index) &&
-      std::find(added_display_indices.begin(),
-                added_display_indices.end(),
-                updated_index) == added_display_indices.end()) {
-    uint32_t metrics = gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS |
-                       gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA;
-    if (display_changes.find(updated_index) != display_changes.end())
-      metrics |= display_changes[updated_index];
+  std::vector<size_t> updated_indices;
+  if (UpdateNonPrimaryDisplayBoundsForLayout(&new_displays, &updated_indices)) {
+    for (std::vector<size_t>::iterator it = updated_indices.begin();
+         it != updated_indices.end(); ++it) {
+      size_t updated_index = *it;
+      if (std::find(added_display_indices.begin(),
+                    added_display_indices.end(),
+                    updated_index) == added_display_indices.end()) {
+        uint32_t metrics = gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS |
+                           gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA;
+        if (display_changes.find(updated_index) != display_changes.end())
+          metrics |= display_changes[updated_index];
 
-    display_changes[updated_index] = metrics;
+        display_changes[updated_index] = metrics;
+      }
+    }
   }
 
   displays_ = new_displays;
 
   base::AutoReset<bool> resetter(&change_display_upon_host_resize_, false);
 
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   displays_.insert(displays_.end(), removed_displays.begin(),
                    removed_displays.end());
@@ skipping 63 matching lines @@
   if (has_mirroring_display && delegate_)
     CreateMirrorWindowAsyncIfAny();
 }
 
 const gfx::Display& DisplayManager::GetDisplayAt(size_t index) const {
   DCHECK_LT(index, displays_.size());
   return displays_[index];
 }
 
 const gfx::Display& DisplayManager::GetPrimaryDisplayCandidate() const {
-  if (GetNumDisplays() == 1)
+  if (GetNumDisplays() != 2)
     return displays_[0];
   DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(
       GetCurrentDisplayIdPair());
   return GetDisplayForId(layout.primary_id);
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return displays_.size();
 }
 
@@ skipping 189 matching lines @@
 
 gfx::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64 id) {
   DCHECK(display_info_.find(id) != display_info_.end());
   const DisplayInfo& display_info = display_info_[id];
 
   gfx::Display new_display(display_info.id());
   gfx::Rect bounds_in_native(display_info.size_in_pixel());
   float device_scale_factor = display_info.GetEffectiveDeviceScaleFactor();
 
   // Simply set the origin to (0,0).  The primary display's origin is
-  // always (0,0) and the secondary display's bounds will be updated
-  // in |UpdateSecondaryDisplayBoundsForLayout| called in |UpdateDisplay|.
+  // always (0,0) and the bounds of non-primary display(s) will be updated
+  // in |UpdateNonPrimaryDisplayBoundsForLayout| called in |UpdateDisplay|.
   new_display.SetScaleAndBounds(
       device_scale_factor, gfx::Rect(bounds_in_native.size()));
   new_display.set_rotation(display_info.rotation());
   new_display.set_touch_support(display_info.touch_support());
   return new_display;
 }
 
-bool DisplayManager::UpdateSecondaryDisplayBoundsForLayout(
+bool DisplayManager::UpdateNonPrimaryDisplayBoundsForLayout(
     DisplayList* displays,
-    size_t* updated_index) const {
-  if (displays->size() != 2U)
+    std::vector<size_t>* updated_indices) const {
+
+  if (displays->size() < 2U)
     return false;
 
+  if (displays->size() > 2U) {
+    // For more than 2 displays, always use horizontal layout.
+    int x_offset = displays->at(0).bounds().width();
+    for (size_t i = 1; i < displays->size(); ++i) {
+      gfx::Display& display = displays->at(i);
+      const gfx::Rect& bounds = display.bounds();
+      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;
+  }
+
   int64 id_at_zero = displays->at(0).id();
   DisplayIdPair pair =
       (id_at_zero == first_display_id_ ||
        id_at_zero == gfx::Display::InternalDisplayId()) ?
       std::make_pair(id_at_zero, displays->at(1).id()) :
       std::make_pair(displays->at(1).id(), id_at_zero);
   DisplayLayout layout =
       layout_store_->ComputeDisplayLayoutForDisplayIdPair(pair);
 
   // 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;
       secondary_index = 0;
     }
     // This function may be called before the secondary display is
     // registered. The bounds is empty in that case and will
     // return true.
     gfx::Rect bounds =
         GetDisplayForId(displays->at(secondary_index).id()).bounds();
     UpdateDisplayBoundsForLayout(
         layout, displays->at(primary_index), &displays->at(secondary_index));
-    *updated_index = secondary_index;
+    updated_indices->push_back(secondary_index);
     return bounds != displays->at(secondary_index).bounds();
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowIfAny() {
   if (HasSoftwareMirroringDisplay() && delegate_) {
     DisplayInfo display_info = GetDisplayInfo(mirroring_display_.id());
     delegate_->CreateOrUpdateMirroringDisplay(display_info);
   }
@@ skipping 45 matching lines @@
       new_secondary_origin.Offset(-secondary_bounds.width(), offset);
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace ash