Unified Desktop: hook up ash to allow unified desktop mode

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 31 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;
 
@@ skipping 46 matching lines @@
 
 bool IsInternalDisplayId(int64 id) {
   return gfx::Display::InternalDisplayId() == id;
 }
 
 }  // namespace
 
 using std::string;
 using std::vector;
 
+// static
+int64 DisplayManager::kUnifiedDisplayId = -10;
+
 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),
-      second_display_mode_(EXTENDED),
+      multi_display_mode_(EXTENDED),
+      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),
       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;
+
   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) {
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
@@ skipping 17 matching lines @@
   vector<string> parts;
   base::SplitString(size_str, ',', &parts);
   for (vector<string>::const_iterator iter = parts.begin();
        iter != parts.end(); ++iter) {
     info_list.push_back(DisplayInfo::CreateFromSpec(*iter));
     info_list.back().set_native(true);
   }
   MaybeInitInternalDisplay(&info_list[0]);
   if (info_list.size() > 1 &&
       command_line->HasSwitch(switches::kAshEnableSoftwareMirroring)) {
-    SetSecondDisplayMode(MIRRORING);
+    SetMultiDisplayMode(MIRRORING);
   }
   OnNativeDisplaysChanged(info_list);
   return true;
 }
 
 void DisplayManager::InitDefaultDisplay() {
   DisplayInfoList info_list;
   info_list.push_back(DisplayInfo::CreateFromSpec(std::string()));
   info_list.back().set_native(true);
   MaybeInitInternalDisplay(&info_list[0]);
@@ skipping 28 matching lines @@
   }
   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 {
-  if (IsInMirrorMode()) {
+  if (IsInUnifiedMode()) {
+    return std::make_pair(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 std::make_pair(active_display_list_[0].id(), mirroring_display_id_);
   } else {
     CHECK_LE(2u, active_display_list_.size());
     int64 id_at_zero = active_display_list_[0].id();
@@ skipping 353 matching lines @@
     VLOG(1) << "OnNativeDisplaysChanged(1):" << updated_displays[0].ToString();
   } else {
     VLOG(1) << "OnNativeDisplaysChanged(" << updated_displays.size()
             << ") [0]=" << updated_displays[0].ToString()
             << ", [1]=" << updated_displays[1].ToString();
   }
 
   bool internal_display_connected = false;
   num_connected_displays_ = updated_displays.size();
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
-  software_mirroring_display_ = gfx::Display();
+  software_mirroring_display_list_.clear();
   DisplayInfoList new_display_info_list;
   for (DisplayInfoList::const_iterator iter = updated_displays.begin();
        iter != updated_displays.end();
        ++iter) {
     if (!internal_display_connected)
       internal_display_connected = IsInternalDisplayId(iter->id());
     // Mirrored monitors have the same origins.
     gfx::Point origin = iter->bounds_in_native().origin();
     if (origins.find(origin) != origins.end()) {
       InsertAndUpdateDisplayInfo(*iter);
@@ skipping 54 matching lines @@
   std::sort(active_display_list_.begin(), active_display_list_.end(),
             DisplaySortFunctor());
   std::sort(new_display_info_list.begin(),
             new_display_info_list.end(),
             DisplayInfoSortFunctor());
   // Close the mirroring window if any here to avoid creating two compositor on
   // one display.
   if (delegate_)
     delegate_->CloseMirroringDisplay();
 
-  if (second_display_mode_ == MIRRORING && new_display_info_list.size() == 2)
-    CreateSoftwareMirroringDisplay(&new_display_info_list);
+  CreateSoftwareMirroringDisplay(&new_display_info_list);
 
   DisplayList new_displays;
   DisplayList removed_displays;
   std::map<size_t, uint32_t> display_changes;
   std::vector<size_t> added_display_indices;
 
   DisplayList::iterator curr_iter = active_display_list_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   while (curr_iter != active_display_list_.end() ||
@@ skipping 180 matching lines @@
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return active_display_list_.size();
 }
 
 bool DisplayManager::IsInMirrorMode() const {
   return mirroring_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
+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);
   CHECK(iter != display_info_.end()) << display_id;
   return iter->second;
 }
 
+const gfx::Display DisplayManager::GetMirroringDisplayById(
+    int64 display_id) const {
+  auto iter = std::find_if(software_mirroring_display_list_.begin(),
+                           software_mirroring_display_list_.end(),
+                           [display_id](const gfx::Display& display) {
+                             return display.id() == display_id;
+                           });
+  return iter == software_mirroring_display_list_.end() ? gfx::Display()
+                                                        : *iter;
+}
+
 std::string DisplayManager::GetDisplayNameForId(int64 id) {
   if (id == gfx::Display::kInvalidDisplayID)
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
   std::map<int64, DisplayInfo>::const_iterator iter = display_info_.find(id);
   if (iter != display_info_.end() && !iter->second.name().empty())
     return iter->second.name();
 
   return base::StringPrintf("Display %d", static_cast<int>(id));
 }
 
 int64 DisplayManager::GetDisplayIdForUIScaling() const {
   // UI Scaling is effective only on internal display.
   int64 display_id = gfx::Display::InternalDisplayId();
 #if defined(OS_WIN)
   display_id = first_display_id();
 #endif
   return display_id;
 }
 
-void DisplayManager::SetMirrorMode(bool mirrored) {
+void DisplayManager::SetMirrorMode(bool mirror) {
+#if defined(OS_CHROMEOS)
   if (num_connected_displays() <= 1)
     return;
 
-#if defined(OS_CHROMEOS)
   if (base::SysInfo::IsRunningOnChromeOS()) {
     ui::MultipleDisplayState new_state =
-        mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR :
-                   ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
+        mirror ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR
+               : ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
     Shell::GetInstance()->display_configurator()->SetDisplayMode(new_state);
     return;
   }
-#endif
+
   // This is fallback path to emulate mirroroing on desktop.
-  SetSecondDisplayMode(mirrored ? MIRRORING : EXTENDED);
   DisplayInfoList display_info_list;
-  int count = 0;
-  for (std::map<int64, DisplayInfo>::const_iterator iter =
-           display_info_.begin();
-       count < 2; ++iter, ++count) {
-    display_info_list.push_back(GetDisplayInfo(iter->second.id()));
+  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()));
+  }
+
+  SetSoftwareMirroring(mirror);
   UpdateDisplays(display_info_list);
-#if defined(OS_CHROMEOS)
   if (Shell::GetInstance()->display_configurator_animation()) {
     Shell::GetInstance()->display_configurator_animation()->
         StartFadeInAnimation();
   }
 #endif
 }
 
 void DisplayManager::AddRemoveDisplay() {
   DCHECK(!active_display_list_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   const DisplayInfo& first_display =
-      GetDisplayInfo(active_display_list_[0].id());
+      IsInUnifiedMode()
+          ? GetDisplayInfo(software_mirroring_display_list_[0].id())
+          : GetDisplayInfo(active_display_list_[0].id());
   new_display_info_list.push_back(first_display);
   // Add if there is only one display connected.
   if (num_connected_displays() == 1) {
     // Layout the 2nd display below the primary as with the real device.
     gfx::Rect host_bounds = first_display.bounds_in_native();
     new_display_info_list.push_back(DisplayInfo::CreateFromSpec(
         base::StringPrintf(
             "%d+%d-500x400", host_bounds.x(), host_bounds.bottom())));
   }
   num_connected_displays_ = new_display_info_list.size();
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
-  software_mirroring_display_ = gfx::Display();
+  software_mirroring_display_list_.clear();
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!active_display_list_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   for (DisplayList::const_iterator iter = active_display_list_.begin();
        iter != active_display_list_.end(); ++iter) {
     DisplayInfo display_info = GetDisplayInfo(iter->id());
     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) {
-  SetSecondDisplayMode(enabled ? MIRRORING : EXTENDED);
+  SetMultiDisplayMode(enabled ? MIRRORING : default_multi_display_mode_);
 }
 
 bool DisplayManager::SoftwareMirroringEnabled() const {
   return software_mirroring_enabled();
 }
 #endif
 
-void DisplayManager::SetSecondDisplayMode(SecondDisplayMode mode) {
-  second_display_mode_ = mode;
+void DisplayManager::SetMultiDisplayMode(MultiDisplayMode mode) {
+  multi_display_mode_ = mode;
   mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
-  software_mirroring_display_ = gfx::Display();
+  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);
+  default_multi_display_mode_ = mode;
 }
 
 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,
                                   gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
     return true;
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowAsyncIfAny() {
   // Do not post a task if the software mirroring doesn't exist, or
   // during initialization when compositor's init task isn't posted yet.
   // ash::Shell::Init() will call this after the compositor is initialized.
-  if (!software_mirroring_display_.is_valid() || !delegate_)
+  if (software_mirroring_display_list_.empty() || !delegate_)
     return;
   base::MessageLoopForUI::current()->PostTask(
       FROM_HERE,
       base::Bind(&DisplayManager::CreateMirrorWindowIfAny,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 scoped_ptr<MouseWarpController> DisplayManager::CreateMouseWarpController(
     aura::Window* drag_source) const {
   // Extra check for |num_connected_displays()| is for SystemDisplayApiTest
@@ skipping 22 matching lines @@
   DisplayInfo* info = &display_info_[gfx::Display::InternalDisplayId()];
   SetInternalDisplayModeList(info);
 }
 
 void DisplayManager::CreateSoftwareMirroringDisplay(
     DisplayInfoList* display_info_list) {
   // Use the internal display or 1st as the mirror source, then scale
   // the root window so that it matches the external display's
   // resolution. This is necessary in order for scaling to work while
   // mirrored.
+  // int64 mirroring_display_id = gfx::Display::kInvalidDisplayID;
+  if (display_info_list->size() == 2) {
+    switch (multi_display_mode_) {
+      case MIRRORING: {
+        bool zero_is_source =
+            first_display_id_ == (*display_info_list)[0].id() ||
+            gfx::Display::InternalDisplayId() == (*display_info_list)[0].id();
+        DCHECK_EQ(MIRRORING, multi_display_mode_);
+        mirroring_display_id_ =
+            (*display_info_list)[zero_is_source ? 1 : 0].id();
+
+        int64 display_id = mirroring_display_id_;
+        auto iter =
+            std::find_if(display_info_list->begin(), display_info_list->end(),
+                         [display_id](const DisplayInfo& info) {
+                           return info.id() == display_id;
+                         });
+        DCHECK(iter != display_info_list->end());
+
+        DisplayInfo info = *iter;
+        info.SetOverscanInsets(gfx::Insets());
+        InsertAndUpdateDisplayInfo(info);
+        software_mirroring_display_list_.push_back(
+            CreateDisplayFromDisplayInfoById(mirroring_display_id_));
+        display_info_list->erase(iter);
+      } break;

[Jun Mukai, 2015/04/26 23:45:08]

I prefer to write
  break;
}
order.

[oshima, 2015/04/27 17:48:38]

Done.

+      case UNIFIED: {
+        gfx::Rect unified_bounds;
+        software_mirroring_display_list_.clear();
+        for (auto& info : *display_info_list) {
+          InsertAndUpdateDisplayInfo(info);
+          software_mirroring_display_list_.push_back(
+              CreateDisplayFromDisplayInfoById(info.id()));
+          gfx::Point origin(unified_bounds.right(), 0);
+          unified_bounds.Union(gfx::Rect(origin, info.size_in_pixel()));
+        }
+        // first_display_id_ = kUnifiedDisplayId;
+        DisplayInfo info(kUnifiedDisplayId, "Unified Desktop", false);
+        info.SetBounds(unified_bounds);
+        display_info_list->clear();
+        display_info_list->push_back(info);
+      } break;
+      case EXTENDED:
+        break;
+    }
+  }
+#if 0
+  // Use the internal display or 1st as the mirror source, then scale
+  // the root window so that it matches the external display's
+  // resolution. This is necessary in order for scaling to work while
+  // mirrored.
   bool zero_is_source =
       first_display_id_ == (*display_info_list)[0].id() ||
       gfx::Display::InternalDisplayId() == (*display_info_list)[0].id();
-  DCHECK_EQ(MIRRORING, second_display_mode_);
+  DCHECK_EQ(MIRRORING, multi_display_mode_);
   mirroring_display_id_ = (*display_info_list)[zero_is_source ? 1 : 0].id();
   int64 display_id = mirroring_display_id_;
   auto iter = std::find_if(display_info_list->begin(), display_info_list->end(),
                            [display_id](const DisplayInfo& info) {
                              return info.id() == display_id;
                            });
   DCHECK(iter != display_info_list->end());
   DisplayInfo info = *iter;
   info.SetOverscanInsets(gfx::Insets());
   InsertAndUpdateDisplayInfo(info);
   software_mirroring_display_ =
       CreateDisplayFromDisplayInfoById(mirroring_display_id_);
   display_info_list->erase(iter);
+#endif

[oshima, 2015/04/27 17:48:38]

oops, I forgot to remove this. Removed.

 }
 
 gfx::Display* DisplayManager::FindDisplayForId(int64 id) {
   auto iter = std::find_if(
       active_display_list_.begin(), active_display_list_.end(),
       [id](const gfx::Display& display) { return display.id() == id; });
   if (iter != active_display_list_.end())
     return &(*iter);
-  DLOG(WARNING) << "Could not find display:" << id;
+  // TODO(oshima): This happens when a windows in unified desktop have
+  // been moved to normal window. Fix this.
+  if (id != kUnifiedDisplayId)
+    DLOG(WARNING) << "Could not find display:" << id;
   return NULL;
 }
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
   if (software_mirroring_enabled() && IsInMirrorMode())
     display_info_list->push_back(GetDisplayInfo(mirroring_display_id_));
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
@@ skipping 13 matching lines @@
 #if defined(OS_CHROMEOS)
   ui::ColorCalibrationProfile color_profile = display_info.color_profile();
   if (color_profile != ui::COLOR_PROFILE_STANDARD) {
     Shell::GetInstance()->display_configurator()->SetColorCalibrationProfile(
         display_info.id(), color_profile);
   }
 #endif
 }
 
 gfx::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64 id) {
-  DCHECK(display_info_.find(id) != display_info_.end());
+  DCHECK(display_info_.find(id) != display_info_.end()) << "id=" << id;
   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 bounds of non-primary display(s) will be updated
   // in |UpdateNonPrimaryDisplayBoundsForLayout| called in |UpdateDisplay|.
   new_display.SetScaleAndBounds(
@@ skipping 53 matching lines @@
         GetDisplayForId(displays->at(secondary_index).id()).bounds();
     UpdateDisplayBoundsForLayout(
         layout, displays->at(primary_index), &displays->at(secondary_index));
     updated_indices->push_back(secondary_index);
     return bounds != displays->at(secondary_index).bounds();
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowIfAny() {
-  if (software_mirroring_display_.is_valid() && delegate_) {
-    DisplayInfo display_info = GetDisplayInfo(software_mirroring_display_.id());
-    delegate_->CreateOrUpdateMirroringDisplay(display_info);
-  }
+  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);
 }
 
 // static
 void DisplayManager::UpdateDisplayBoundsForLayout(
     const DisplayLayout& layout,
     const gfx::Display& primary_display,
     gfx::Display* secondary_display) {
   DCHECK_EQ("0,0", primary_display.bounds().origin().ToString());
 
   const gfx::Rect& primary_bounds = primary_display.bounds();
@@ skipping 30 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);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
-  if (software_mirroring_display_.is_valid())
+  if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash