Fix software mirror mode on Ozone part 2/2

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 100 matching lines @@
 DisplayManager::DisplayManager()
     : delegate_(NULL),
       screen_ash_(new ScreenAsh),
       screen_(screen_ash_.get()),
       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),
-      mirrored_display_id_(gfx::Display::kInvalidDisplayID),
+      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);
 
   change_display_upon_host_resize_ = !base::SysInfo::IsRunningOnChromeOS();
@@ skipping 101 matching lines @@
 }
 
 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_);
+    return std::make_pair(displays_[0].id(), mirroring_display_id_);
   } else {
     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);
     }
   }
@@ skipping 346 matching lines @@
   if (updated_displays.size() == 1) {
     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();
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   mirroring_display_ = gfx::Display();
   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);
-      mirrored_display_id_ = iter->id();
+      mirroring_display_id_ = iter->id();
+      mirroring_display_ =
+          CreateDisplayFromDisplayInfoById(mirroring_display_id_);
+      mirroring_display_.set_mirrored_display_id(new_display_info_list[0].id());
     } else {
       origins.insert(origin);
       new_display_info_list.push_back(*iter);
     }
 
     DisplayMode new_mode;
     new_mode.size = iter->bounds_in_native().size();
     new_mode.device_scale_factor = iter->device_scale_factor();
     new_mode.ui_scale = iter->configured_ui_scale();
     const std::vector<DisplayMode>& display_modes = iter->display_modes();
@@ skipping 53 matching lines @@
 
   DisplayList::iterator curr_iter = displays_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   DisplayList new_displays;
 
   // 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 mirroing_display_id = gfx::Display::kInvalidDisplayID;
+  int64 mirrored_display_id = gfx::Display::kInvalidDisplayID;
+  int64 mirroring_display_id = gfx::Display::kInvalidDisplayID;
 
   if (second_display_mode_ != EXTENDED && new_display_info_list.size() == 2) {
     bool zero_is_source =
         first_display_id_ == new_display_info_list[0].id() ||
         gfx::Display::InternalDisplayId() == new_display_info_list[0].id();
     DCHECK_EQ(MIRRORING, second_display_mode_);
-    mirrored_display_id_ = new_display_info_list[zero_is_source ? 1 : 0].id();
-    mirroing_display_id = mirrored_display_id_;
+    mirrored_display_id = new_display_info_list[zero_is_source ? 0 : 1].id();
+    mirroring_display_id = new_display_info_list[zero_is_source ? 1 : 0].id();
+    mirroring_display_id_ = mirroring_display_id;
   }
 
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (new_info_iter != new_display_info_list.end() &&
-        mirroing_display_id == new_info_iter->id()) {
+        mirroring_display_id == new_info_iter->id()) {
       DisplayInfo info = *new_info_iter;
       info.SetOverscanInsets(gfx::Insets());
       InsertAndUpdateDisplayInfo(info);
       mirroring_display_ =
-          CreateDisplayFromDisplayInfoById(mirroing_display_id);
+          CreateDisplayFromDisplayInfoById(mirroring_display_id);
+      mirroring_display_.set_mirrored_display_id(mirrored_display_id);
       ++new_info_iter;
       // Remove existing external display if it is going to be used as
       // mirroring display.
       if (curr_iter != displays_.end() &&
-          curr_iter->id() == mirroing_display_id) {
+          curr_iter->id() == mirroring_display_id) {
         removed_displays.push_back(*curr_iter);
         ++curr_iter;
       }
       continue;
     }
 
     if (curr_iter == displays_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
@@ skipping 195 matching lines @@
   DisplayLayout layout = layout_store_->GetRegisteredDisplayLayout(
       GetCurrentDisplayIdPair());
   return GetDisplayForId(layout.primary_id);
 }
 
 size_t DisplayManager::GetNumDisplays() const {
   return displays_.size();
 }
 
 bool DisplayManager::IsMirrored() const {
-  return mirrored_display_id_ != gfx::Display::kInvalidDisplayID;
+  return mirroring_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
 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;
 }
@@ skipping 56 matching lines @@
   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();
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   mirroring_display_ = gfx::Display();
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!displays_.empty());
   std::vector<DisplayInfo> new_display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     DisplayInfo display_info = GetDisplayInfo(iter->id());
@@ skipping 10 matching lines @@
   SetSecondDisplayMode(enabled ? MIRRORING : EXTENDED);
 }
 
 bool DisplayManager::SoftwareMirroringEnabled() const {
   return software_mirroring_enabled();
 }
 #endif
 
 void DisplayManager::SetSecondDisplayMode(SecondDisplayMode mode) {
   second_display_mode_ = mode;
-  mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
+  mirroring_display_id_ = gfx::Display::kInvalidDisplayID;
   mirroring_display_ = gfx::Display();
 }
 
 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() && mirrored_display_id_ == display_id)
+    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_ash_->NotifyMetricsChanged(
         *display, gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
     return true;
   }
   return false;
 }
 
@@ skipping 24 matching lines @@
   DisplayInfo* info = &display_info_[gfx::Display::InternalDisplayId()];
   SetInternalDisplayModeList(info);
 }
 
 gfx::Display* DisplayManager::FindDisplayForId(int64 id) {
   for (DisplayList::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return &(*iter);
   }
+
+  if (id == mirroring_display_id_)
+    return &mirroring_display_;
+
   DLOG(WARNING) << "Could not find display:" << id;
   return NULL;
 }
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
   if (software_mirroring_enabled() && IsMirrored())
-    display_info_list->push_back(GetDisplayInfo(mirrored_display_id_));
+    display_info_list->push_back(GetDisplayInfo(mirroring_display_id_));
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
   std::map<int64, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
   if (info != display_info_.end()) {
     info->second.Copy(new_info);
   } else {
     display_info_[new_info.id()] = new_info;
     display_info_[new_info.id()].set_native(false);
@@ skipping 139 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