Allow switching between extended and unified

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 123 matching lines @@
       mirroring_display_id_(gfx::Display::kInvalidDisplayID),
       registered_internal_display_rotation_lock_(false),
       registered_internal_display_rotation_(gfx::Display::ROTATE_0),
       weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   // Enable only on the device so that DisplayManagerFontTest passes.
   if (base::SysInfo::IsRunningOnChromeOS())
     DisplayInfo::SetUse125DSFForUIScaling(true);
 
   if (switches::UnifiedDesktopEnabled())
-    multi_display_mode_ = default_multi_display_mode_ = UNIFIED;
+    default_multi_display_mode_ = UNIFIED;
 
   change_display_upon_host_resize_ = !base::SysInfo::IsRunningOnChromeOS();
 #endif
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_ALTERNATE, screen_.get());
   gfx::Screen* current_native =
       gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE);
   // If there is no native, or the native was for shutdown,
   // use ash's screen.
   if (!current_native ||
       current_native == screen_for_shutdown) {
@@ skipping 512 matching lines @@
       "skip (don't disable) the test using SupportsMultipleDisplays()";
 #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 (multi_display_mode_ != MIRRORING)
+    multi_display_mode_ = 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;
   std::map<size_t, uint32_t> display_changes;
@@ skipping 257 matching lines @@
     if (iter->id() == kUnifiedDisplayId)
       continue;
     display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
   for (auto iter = software_mirroring_display_list_.begin();
        (display_info_list.size() < 2 &&
         iter != software_mirroring_display_list_.end());
        ++iter) {
     display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
-
-  SetSoftwareMirroring(mirror);
-  UpdateDisplays(display_info_list);
+  multi_display_mode_ = mirror ? MIRRORING : default_multi_display_mode_;
+  ReconfigureDisplays();
   if (Shell::GetInstance()->display_configurator_animation()) {
     Shell::GetInstance()->display_configurator_animation()->
         StartFadeInAnimation();
   }
   RunPendingTasksForTest();
 #endif
 }
 
 void DisplayManager::AddRemoveDisplay() {
   DCHECK(!active_display_list_.empty());
@@ skipping 43 matching lines @@
 }
 #endif
 
 void DisplayManager::SetMultiDisplayMode(MultiDisplayMode mode) {
   multi_display_mode_ = mode;
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
 }
 
 void DisplayManager::SetDefaultMultiDisplayMode(MultiDisplayMode mode) {
-  // TODO(oshima): Remove this constrain.
-  DCHECK_EQ(default_multi_display_mode_, EXTENDED);
-  DCHECK_EQ(mode, UNIFIED);
+  DCHECK_NE(mode, MIRRORING);
   default_multi_display_mode_ = mode;
 }
 
+void DisplayManager::ReconfigureDisplays() {
+  DisplayInfoList display_info_list;
+  for (DisplayList::const_iterator iter = active_display_list_.begin();
+       (display_info_list.size() < 2 && iter != active_display_list_.end());
+       ++iter) {
+    if (iter->id() == kUnifiedDisplayId)
+      continue;
+    display_info_list.push_back(GetDisplayInfo(iter->id()));
+  }
+  for (auto iter = software_mirroring_display_list_.begin();
+       (display_info_list.size() < 2 &&
+        iter != software_mirroring_display_list_.end());
+       ++iter) {
+    display_info_list.push_back(GetDisplayInfo(iter->id()));
+  }
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
+  software_mirroring_display_list_.clear();
+  UpdateDisplays(display_info_list);
+}
+
 bool DisplayManager::UpdateDisplayBounds(int64 display_id,
                                          const gfx::Rect& new_bounds) {
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
     if (software_mirroring_enabled() && mirroring_display_id_ == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
     screen_->NotifyMetricsChanged(*display,
@@ skipping 277 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