Allow dynamic enabling/disabling of unified desktop

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 33 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "ash/display/display_configurator_animation.h"
 #include "base/sys_info.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
-#include "base/debug/stack_trace.h"
-
 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 = NULL;
 
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 100;
 
 struct DisplaySortFunctor {
   bool operator()(const gfx::Display& a, const gfx::Display& b) {
-    return a.id() < b.id();
+    return CompareDisplayIds(a.id(), b.id());
   }
 };
 
 struct DisplayInfoSortFunctor {
   bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
-    return a.id() < b.id();
+    return CompareDisplayIds(a.id(), b.id());
   }
 };
 
 gfx::Display& GetInvalidDisplay() {
   static gfx::Display* invalid_display = new gfx::Display();
   return *invalid_display;
 }
 
 std::vector<DisplayMode>::const_iterator FindDisplayMode(
     const DisplayInfo& info,
@@ skipping 41 matching lines @@
 
 DisplayManager::DisplayManager()
     : delegate_(NULL),
       screen_(new ScreenAsh),
       layout_store_(new DisplayLayoutStore),
       first_display_id_(gfx::Display::kInvalidDisplayID),
       num_connected_displays_(0),
       force_bounds_changed_(false),
       change_display_upon_host_resize_(false),
       multi_display_mode_(EXTENDED),
-      default_multi_display_mode_(EXTENDED),
+      current_default_multi_display_mode_(EXTENDED),
       mirroring_display_id_(gfx::Display::kInvalidDisplayID),
       registered_internal_display_rotation_lock_(false),
       registered_internal_display_rotation_(gfx::Display::ROTATE_0),
+      unified_desktop_enabled_(false),
       weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   change_display_upon_host_resize_ = !base::SysInfo::IsRunningOnChromeOS();
+  unified_desktop_enabled_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kAshEnableUnifiedDesktop);
 #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) {
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
   }
@@ skipping 457 matching lines @@
       // active again.
       gfx::Display::Rotation user_rotation =
           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 (new_display_info_list.size() > 1) {
-    std::sort(new_display_info_list.begin(), new_display_info_list.end(),
-              DisplayInfoSortFunctor());
+  if (!base::SysInfo::IsRunningOnChromeOS() &&
+      new_display_info_list.size() > 1) {
     DisplayIdPair pair = CreateDisplayIdPair(new_display_info_list[0].id(),
                                              new_display_info_list[1].id());
     DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(pair);
-    default_multi_display_mode_ =
-        (layout.default_unified && switches::UnifiedDesktopEnabled())
-            ? UNIFIED
-            : EXTENDED;
     // Mirror mode is set by DisplayConfigurator on the device.
     // Emulate it when running on linux desktop.
-    if (!base::SysInfo::IsRunningOnChromeOS() && layout.mirrored)
+    if (layout.mirrored)
       SetMultiDisplayMode(MIRRORING);
   }
 #endif
 
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::UpdateDisplays() {
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_)
@@ skipping 10 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 (new_display_info_list.size() > 1) {
+    DisplayIdPair pair = CreateDisplayIdPair(new_display_info_list[0].id(),
+                                             new_display_info_list[1].id());
+    DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(pair);
+    current_default_multi_display_mode_ =
+        (layout.default_unified && unified_desktop_enabled_) ? UNIFIED
+                                                             : EXTENDED;
+  }
+
   if (multi_display_mode_ != MIRRORING)
-    multi_display_mode_ = default_multi_display_mode_;
+    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;
@@ skipping 185 matching lines @@
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return active_display_list_.size();
 }
 
 bool DisplayManager::IsInMirrorMode() const {
   return mirroring_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
+void DisplayManager::SetUnifiedDesktopEnabled(bool enable) {
+  unified_desktop_enabled_ = enable;
+  ReconfigureDisplays();
+}
+
 bool DisplayManager::IsInUnifiedMode() const {
   return multi_display_mode_ == UNIFIED &&
          !software_mirroring_display_list_.empty();
 }
 
 const DisplayInfo& DisplayManager::GetDisplayInfo(int64 display_id) const {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, display_id);
 
   std::map<int64, DisplayInfo>::const_iterator iter =
       display_info_.find(display_id);
@@ skipping 34 matching lines @@
   if (num_connected_displays() <= 1)
     return;
 
   if (base::SysInfo::IsRunningOnChromeOS()) {
     ui::MultipleDisplayState new_state =
         mirror ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR
                : ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
     Shell::GetInstance()->display_configurator()->SetDisplayMode(new_state);
     return;
   }
-  multi_display_mode_ = mirror ? MIRRORING : default_multi_display_mode_;
+  multi_display_mode_ =
+      mirror ? MIRRORING : current_default_multi_display_mode_;
   ReconfigureDisplays();
   if (Shell::GetInstance()->display_configurator_animation()) {
     Shell::GetInstance()->display_configurator_animation()->
         StartFadeInAnimation();
   }
   RunPendingTasksForTest();
 #endif
 }
 
 void DisplayManager::AddRemoveDisplay() {
@@ skipping 29 matching lines @@
     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);
   UpdateDisplays(new_display_info_list);
 }
 
 #if defined(OS_CHROMEOS)
 void DisplayManager::SetSoftwareMirroring(bool enabled) {
-  SetMultiDisplayMode(enabled ? MIRRORING : default_multi_display_mode_);
+  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);
+  DisplayIdPair pair = GetCurrentDisplayIdPair();
+  layout_store_->UpdateMultiDisplayState(pair, IsInMirrorMode(),
+                                         mode == UNIFIED);
+}
+
 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) {
-  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();
@@ skipping 379 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