Use the source display's pixel size as a mirror window's size.

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 <cmath>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 232 matching lines @@
 void DisplayManager::SetOverscanInsets(int64 display_id,
                                        const gfx::Insets& insets_in_dip) {
   // TODO(oshima): insets has to be rotated according to the
   // the current display rotation.
   display_info_[display_id].SetOverscanInsets(true, insets_in_dip);
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
+  AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::ClearCustomOverscanInsets(int64 display_id) {
   display_info_[display_id].clear_has_custom_overscan_insets();
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
+  AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::SetDisplayRotation(int64 display_id,
                                         gfx::Display::Rotation rotation) {
   if (!IsDisplayRotationEnabled())
     return;
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     DisplayInfo info = GetDisplayInfo(iter->id());
     if (info.id() == display_id) {
       if (info.rotation() == rotation)
         return;
       info.set_rotation(rotation);
     }
     display_info_list.push_back(info);
   }
+  AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::SetDisplayUIScale(int64 display_id,
                                        float ui_scale) {
   if (!IsDisplayUIScalingEnabled() ||
       gfx::Display::InternalDisplayId() != display_id) {
     return;
   }
 
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     DisplayInfo info = GetDisplayInfo(iter->id());
     if (info.id() == display_id) {
       if (info.ui_scale() == ui_scale)
         return;
       std::vector<float> scales = GetScalesForDisplay(info);
       ScaleComparator comparator(ui_scale);
       if (std::find_if(scales.begin(), scales.end(), comparator) ==
           scales.end()) {
         return;
       }
       info.set_ui_scale(ui_scale);
     }
     display_info_list.push_back(info);
   }
+  AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::RegisterDisplayProperty(
     int64 display_id,
     gfx::Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets) {
   if (display_info_.find(display_id) == display_info_.end()) {
     display_info_[display_id] =
@@ skipping 86 matching lines @@
   }
   UpdateDisplays(new_display_info_list);
 }
 
 void DisplayManager::UpdateDisplays() {
   DisplayInfoList display_info_list;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     display_info_list.push_back(GetDisplayInfo(iter->id()));
   }
+  AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplays(display_info_list);
 }
 
 void DisplayManager::UpdateDisplays(
     const std::vector<DisplayInfo>& updated_display_info_list) {
   DisplayInfoList new_display_info_list = updated_display_info_list;
   std::sort(displays_.begin(), displays_.end(), DisplaySortFunctor());
   std::sort(new_display_info_list.begin(),
             new_display_info_list.end(),
             DisplayInfoSortFunctor());
   DisplayList removed_displays;
   std::vector<size_t> changed_display_indices;
   std::vector<size_t> added_display_indices;
 
   DisplayList::iterator curr_iter = displays_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   DisplayList new_displays;
   bool update_mouse_location = false;
 
   scoped_ptr<MirrorWindowUpdater> mirror_window_updater;
-  // TODO(oshima): We may want to use external as the source.
+  // 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.
   int mirrored_display_id = gfx::Display::kInvalidDisplayID;
-  if (software_mirroring_enabled_ && updated_display_info_list.size() == 2)
-    mirrored_display_id = updated_display_info_list[1].id();
+  if (software_mirroring_enabled_ && new_display_info_list.size() == 2)
+    mirrored_display_id = new_display_info_list[1].id();
 
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (new_info_iter != new_display_info_list.end() &&
         mirrored_display_id == new_info_iter->id()) {
-      InsertAndUpdateDisplayInfo(*new_info_iter);
+      DisplayInfo info = *new_info_iter;
+      info.SetOverscanInsets(true, gfx::Insets());
+      InsertAndUpdateDisplayInfo(info);
+
       mirrored_display_ = CreateDisplayFromDisplayInfoById(new_info_iter->id());
       mirror_window_updater.reset(
           new MirrorWindowCreator(display_info_[new_info_iter->id()]));
       ++new_info_iter;
       // Remove existing external dispaly if it is going to be mirrored.
       if (curr_iter != displays_.end() &&
           curr_iter->id() == mirrored_display_id) {
         removed_displays.push_back(*curr_iter);
         ++curr_iter;
       }
@@ skipping 95 matching lines @@
     displays_.pop_back();
   }
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyDisplayAdded(displays_[*iter]);
   }
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyBoundsChanged(displays_[*iter]);
   }
+  mirror_window_updater.reset();
   display_controller->NotifyDisplayConfigurationChanged();
   if (update_mouse_location)
     display_controller->EnsurePointerInDisplays();
   else
     display_controller->UpdateMouseCursor(mouse_location_in_native);
 
 #if defined(USE_X11) && defined(OS_CHROMEOS)
   if (!changed_display_indices.empty() && base::chromeos::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
 #endif
@@ skipping 71 matching lines @@
       matching = &(*iter);
     }
   }
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : DisplayController::GetPrimaryDisplay();
 }
 
 const DisplayInfo& DisplayManager::GetDisplayInfo(int64 display_id) const {
   std::map<int64, DisplayInfo>::const_iterator iter =
       display_info_.find(display_id);
-  CHECK(iter != display_info_.end());
+  CHECK(iter != display_info_.end()) << display_id;
   return iter->second;
 }
 
 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();
@@ skipping 39 matching lines @@
   if (num_connected_displays() == 1) {
     // Layout the 2nd display below the primary as with the real device.
     aura::RootWindow* primary = Shell::GetPrimaryRootWindow();
     gfx::Rect host_bounds =
         gfx::Rect(primary->GetHostOrigin(),  primary->GetHostSize());
     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_ = 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());
     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);
 }
 
 void DisplayManager::OnRootWindowResized(const aura::RootWindow* root,
                                          const gfx::Size& old_size) {
   if (change_display_upon_host_resize_) {
     gfx::Display& display = FindDisplayForRootWindow(root);
     gfx::Size old_display_size_in_pixel = display.GetSizeInPixel();
     display_info_[display.id()].SetBounds(
         gfx::Rect(root->GetHostOrigin(), root->GetHostSize()));
     const gfx::Size& new_root_size = root->bounds().size();
+    // It's tricky to support resizing mirror window on desktop.
+    if (software_mirroring_enabled_ && mirrored_display_.id() == display.id())
+      return;
     if (old_size != new_root_size) {
       display.SetSize(display_info_[display.id()].size_in_pixel());
       Shell::GetInstance()->screen()->NotifyBoundsChanged(display);
+      Shell::GetInstance()->mirror_window_controller()->
+          UpdateWindow();
     }
   }
 }
 
 void DisplayManager::SetSoftwareMirroring(bool enabled) {
   software_mirroring_enabled_ = enabled;
   mirrored_display_ = gfx::Display();
 }
 
 int64 DisplayManager::GetDisplayIdForUIScaling() const {
@@ skipping 43 matching lines @@
 gfx::Display& DisplayManager::FindDisplayForId(int64 id) {
   for (DisplayList::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return *iter;
   }
   DLOG(WARNING) << "Could not find display:" << id;
   return GetInvalidDisplay();
 }
 
+void DisplayManager::AddMirrorDisplayInfoIfAny(
+    std::vector<DisplayInfo>* display_info_list) {
+  if (software_mirroring_enabled_ && mirrored_display_.is_valid())
+    display_info_list->push_back(GetDisplayInfo(mirrored_display_.id()));
+}
+
 void DisplayManager::AddDisplayFromSpec(const std::string& spec) {
   DisplayInfo display_info = DisplayInfo::CreateFromSpec(spec);
   InsertAndUpdateDisplayInfo(display_info);
   gfx::Display display = CreateDisplayFromDisplayInfoById(display_info.id());
   displays_.push_back(display);
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
   std::map<int64, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
@@ skipping 17 matching lines @@
   // always (0,0) and the secondary display's bounds will be updated
   // by |DisplayController::UpdateDisplayBoundsForLayout|.
   new_display.SetScaleAndBounds(
       display_info.device_scale_factor(), gfx::Rect(bounds_in_pixel.size()));
   new_display.set_rotation(display_info.rotation());
   return new_display;
 }
 
 }  // namespace internal
 }  // namespace ash