Undo all existing overscan settings before updating to a new overscan settings (2nd)

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 <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 126 matching lines @@
        iter != displays_.end(); ++iter) {
     const gfx::Display& display = *iter;
     if (display.bounds().Contains(point_in_screen))
       return display;
   }
   return GetInvalidDisplay();
 }
 
 void DisplayManager::SetOverscanInsets(int64 display_id,
                                        const gfx::Insets& insets_in_dip) {
+  display_info_[display_id].overscan_insets_in_dip = insets_in_dip;
+
+  // Copies the |displays_| because UpdateDisplays() compares the passed
+  // displays and its internal |displays_|.
   DisplayList displays = displays_;
-  std::map<int64, gfx::Insets>::const_iterator old_overscan =
-      overscan_mapping_.find(display_id);
-  if (old_overscan != overscan_mapping_.end()) {
-    gfx::Insets old_insets = old_overscan->second;
-    for (DisplayList::iterator iter = displays.begin();
-         iter != displays.end(); ++iter) {
-      if (iter->id() == display_id) {
-        // Undo the existing insets before applying the new insets.
-        gfx::Rect bounds = iter->bounds_in_pixel();
-        bounds.Inset(old_insets.Scale(-iter->device_scale_factor()));
-        iter->SetScaleAndBounds(iter->device_scale_factor(), bounds);
-        break;
-      }
-    }
-  }
-  overscan_mapping_[display_id] = insets_in_dip;
-  OnNativeDisplaysChanged(displays);
+  UpdateDisplays(displays);
 }
 
 gfx::Insets DisplayManager::GetOverscanInsets(int64 display_id) const {
-  std::map<int64, gfx::Insets>::const_iterator it =
-      overscan_mapping_.find(display_id);
-  return (it != overscan_mapping_.end()) ? it->second : gfx::Insets();
+  std::map<int64, DisplayInfo>::const_iterator it =
+      display_info_.find(display_id);
+  return (it != display_info_.end()) ?
+      it->second.overscan_insets_in_dip : gfx::Insets();
 }
 
 void DisplayManager::OnNativeDisplaysChanged(
     const std::vector<gfx::Display>& updated_displays) {
   if (updated_displays.empty()) {
     // Don't update the displays when all displays are disconnected.
     // This happens when:
     // - the device is idle and powerd requested to turn off all displays.
     // - the device is suspended. (kernel turns off all displays)
     // - the internal display's brightness is set to 0 and no external
@@ skipping 23 matching lines @@
       if (!internal_display_.get()) {
         internal_display_.reset(new gfx::Display(internal_display_id_,
                                                  gfx::Rect(800, 600)));
       }
       new_displays.push_back(*internal_display_.get());
     }
   } else {
     new_displays = updated_displays;
   }
 
+  for (DisplayList::const_iterator iter = new_displays.begin();
+       iter != new_displays.end(); ++iter) {
+    std::map<int64, DisplayInfo>::iterator info =
+        display_info_.find(iter->id());
+    if (info != display_info_.end()) {
+      info->second.original_bounds_in_pixel = iter->bounds_in_pixel();
+    } else {
+      display_info_[iter->id()].original_bounds_in_pixel =
+          iter->bounds_in_pixel();
+    }
+  }
+
+  UpdateDisplays(new_displays);
+  RefreshDisplayNames();
+}
+
+void DisplayManager::UpdateDisplays(
+    const std::vector<gfx::Display>& updated_displays) {
+  DisplayList new_displays = updated_displays;
+
   for (DisplayList::iterator iter = new_displays.begin();
        iter != new_displays.end(); ++iter) {
-    std::map<int64, gfx::Insets>::const_iterator overscan_insets =
-        overscan_mapping_.find(iter->id());
-    if (overscan_insets != overscan_mapping_.end()) {
-      gfx::Rect bounds = iter->bounds_in_pixel();
-      bounds.Inset(overscan_insets->second.Scale(iter->device_scale_factor()));
+    std::map<int64, DisplayInfo>::const_iterator info =
+        display_info_.find(iter->id());
+    if (info != display_info_.end()) {
+      gfx::Rect bounds = info->second.original_bounds_in_pixel;
+      bounds.Inset(info->second.overscan_insets_in_dip.Scale(
+          iter->device_scale_factor()));
       iter->SetScaleAndBounds(iter->device_scale_factor(), bounds);
     }
   }
 
   std::sort(displays_.begin(), displays_.end(), DisplaySortFunctor());
   std::sort(new_displays.begin(), new_displays.end(), DisplaySortFunctor());
   DisplayList removed_displays;
   std::vector<size_t> changed_display_indices;
   std::vector<size_t> added_display_indices;
   gfx::Display current_primary;
@@ skipping 43 matching lines @@
 
   // Do not update |displays_| if there's nothing to be updated. Without this,
   // it will not update the display layout, which causes the bug
   // http://crbug.com/155948.
   if (changed_display_indices.empty() && added_display_indices.empty() &&
       removed_displays.empty()) {
     return;
   }
 
   displays_ = new_displays;
-  RefreshDisplayNames();
 
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   displays_.insert(displays_.end(), removed_displays.begin(),
                    removed_displays.end());
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyBoundsChanged(displays_[*iter]);
   }
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
@@ skipping 77 matching lines @@
   }
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : DisplayController::GetPrimaryDisplay();
 }
 
 std::string DisplayManager::GetDisplayNameFor(
     const gfx::Display& display) {
   if (!display.is_valid())
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
-  std::map<int64, std::string>::const_iterator iter =
-      display_names_.find(display.id());
-  if (iter != display_names_.end())
-    return iter->second;
+  std::map<int64, DisplayInfo>::const_iterator iter =
+      display_info_.find(display.id());
+  if (iter != display_info_.end())
+    return iter->second.name;
 
   return base::StringPrintf("Display %d", static_cast<int>(display.id()));
 }
 
 void DisplayManager::OnRootWindowResized(const aura::RootWindow* root,
                                          const gfx::Size& old_size) {
   if (!aura::UseFullscreenHostWindow()) {
     gfx::Display& display = FindDisplayForRootWindow(root);
     if (display.size() != root->GetHostSize()) {
       display.SetSize(root->GetHostSize());
@@ skipping 132 matching lines @@
 
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   aura::client::ScreenPositionClient* client =
       aura::client::GetScreenPositionClient(root_window);
   client->ConvertPointFromScreen(root_window, &target_location);
 
   root_window->MoveCursorTo(target_location);
 }
 
 void DisplayManager::RefreshDisplayNames() {
-  display_names_.clear();
-
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
 #endif
 
 #if defined(USE_X11)
   std::vector<XID> outputs;
   if (!ui::GetOutputDeviceHandles(&outputs))
     return;
 
   for (size_t i = 0; i < outputs.size(); ++i) {
     uint16 manufacturer_id = 0;
     uint32 serial_number = 0;
     std::string name;
     if (ui::GetOutputDeviceData(
             outputs[i], &manufacturer_id, &serial_number, &name)) {
       int64 id = gfx::Display::GetID(manufacturer_id, serial_number);
       if (IsInternalDisplayId(id)) {
-        display_names_[id] =
+        display_info_[id].name =
             l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME);
       } else {
-        display_names_[id] = name;
+        display_info_[id].name = name;
       }
     }
   }
 #endif
 }
 
 void DisplayManager::SetDisplayIdsForTest(DisplayList* to_update) const {
   DisplayList::iterator iter_to_update = to_update->begin();
   DisplayList::const_iterator iter = displays_.begin();
   for (; iter != displays_.end() && iter_to_update != to_update->end();
        ++iter, ++iter_to_update) {
     (*iter_to_update).set_id((*iter).id());
   }
 }
 
 }  // namespace internal
 }  // namespace ash