Add OnDisplayMetricsChanged in DisplayObserver.

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>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/screen_ash.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/display.h"
+#include "ui/gfx/display_observer.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "ash/display/display_configurator_animation.h"
@@ skipping 300 matching lines @@
       delegate_->PreDisplayConfigurationChange(false);
     // PreDisplayConfigurationChange(false);
     // TODO(oshima): Call UpdateDisplays instead.
     const DisplayLayout layout = GetCurrentDisplayLayout();
     UpdateDisplayBoundsForLayoutById(
         layout, primary,
         ScreenUtil::GetSecondaryDisplay().id());
 
     // Primary's bounds stay the same. Just notify bounds change
     // on the secondary.
-    screen_ash_->NotifyBoundsChanged(
-        ScreenUtil::GetSecondaryDisplay());
+    int metrics = gfx::DisplayObserver::DISPLAY_METRICS_BOUNDS |
+        gfx::DisplayObserver::DISPLAY_METRICS_WORK_AREA;
+    screen_ash_->NotifyMetricsChanged(ScreenUtil::GetSecondaryDisplay(),
+        static_cast<gfx::DisplayObserver::DisplayMetrics>(metrics));
     if (delegate_)
       delegate_->PostDisplayConfigurationChange();
   }
 }
 
 const gfx::Display& DisplayManager::GetDisplayForId(int64 id) const {
   gfx::Display* display =
       const_cast<DisplayManager*>(this)->FindDisplayForId(id);
   return display ? *display : GetInvalidDisplay();
 }
@@ skipping 276 matching lines @@
         "skip (don't disable) the test using SupportsMultipleDisplays()";
   }
 #endif
 
   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::map<size_t, gfx::DisplayObserver::DisplayMetrics> display_changes;
   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;
 
   // 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
@@ skipping 49 matching lines @@
     } else if (curr_iter->id() == new_info_iter->id()) {
       const gfx::Display& current_display = *curr_iter;
       // Copy the info because |CreateDisplayFromInfo| updates the instance.
       const DisplayInfo current_display_info =
           GetDisplayInfo(current_display.id());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       gfx::Display new_display =
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
       const DisplayInfo& new_display_info = GetDisplayInfo(new_display.id());
 
-      bool host_window_bounds_changed =
-          current_display_info.bounds_in_native() !=
-          new_display_info.bounds_in_native();
+      int metrics = gfx::DisplayObserver::DISPLAY_METRICS_NONE;
 
+      // At that point the new Display objects we have are not entirely updated,
+      // they are missing the translation related to the Display disposition in
+      // the layout.
+      // Using display.bounds() and display.work_area() would fail most of the
+      // time.
       if (force_bounds_changed_ ||
-          host_window_bounds_changed ||
-          (current_display.device_scale_factor() !=
-           new_display.device_scale_factor()) ||
+          (current_display_info.bounds_in_native() !=
+           new_display_info.bounds_in_native()) ||
           (current_display_info.size_in_pixel() !=
-           new_display.GetSizeInPixel()) ||
-          (current_display.rotation() != new_display.rotation())) {
-        changed_display_indices.push_back(new_displays.size());
+           new_display.GetSizeInPixel())) {
+        metrics |= gfx::DisplayObserver::DISPLAY_METRICS_BOUNDS |
+            gfx::DisplayObserver::DISPLAY_METRICS_WORK_AREA;
+      }
+
+      if (current_display.device_scale_factor() !=
+          new_display.device_scale_factor()) {
+        metrics |= gfx::DisplayObserver::DISPLAY_METRICS_DEVICE_SCALE_FACTOR;
+      }
+
+      if (current_display.rotation() != new_display.rotation())
+        metrics |= gfx::DisplayObserver::DISPLAY_METRICS_ROTATION;
+
+      if (metrics != gfx::DisplayObserver::DISPLAY_METRICS_NONE) {
+        display_changes.insert(
+            std::pair<size_t, gfx::DisplayObserver::DisplayMetrics>(
+                new_displays.size(),
+                static_cast<gfx::DisplayObserver::DisplayMetrics>(metrics)));
       }
 
       new_display.UpdateWorkAreaFromInsets(current_display.GetWorkAreaInsets());
       new_displays.push_back(new_display);
       ++curr_iter;
       ++new_info_iter;
     } else if (curr_iter->id() < new_info_iter->id()) {
       // more displays in current list between ids, which means it is deleted.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
     } else {
       // more displays in new list between ids, which means it is added.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     }
   }
 
   scoped_ptr<NonDesktopDisplayUpdater> non_desktop_display_updater(
       new NonDesktopDisplayUpdater(this, delegate_));
 
   // 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() &&
+  if (display_changes.empty() && added_display_indices.empty() &&
       removed_displays.empty()) {
     return;
   }
   // Clear focus if the display has been removed, but don't clear focus if
   // the destkop has been moved from one display to another
   // (mirror -> docked, docked -> single internal).
   bool clear_focus =
       !removed_displays.empty() &&
       !(removed_displays.size() == 1 && added_display_indices.size() == 1);
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(clear_focus);
 
   size_t updated_index;
   if (UpdateSecondaryDisplayBoundsForLayout(&new_displays, &updated_index) &&
       std::find(added_display_indices.begin(),
                 added_display_indices.end(),
-                updated_index) == added_display_indices.end() &&
-      std::find(changed_display_indices.begin(),
-                changed_display_indices.end(),
-                updated_index) == changed_display_indices.end()) {
-    changed_display_indices.push_back(updated_index);
+                updated_index) == added_display_indices.end()) {
+    int metrics = gfx::DisplayObserver::DISPLAY_METRICS_BOUNDS |
+        gfx::DisplayObserver::DISPLAY_METRICS_WORK_AREA;
+    if (display_changes.find(updated_index) != display_changes.end())
+      metrics |= display_changes[updated_index];
+
+    display_changes[updated_index] =
+        static_cast<gfx::DisplayObserver::DisplayMetrics>(metrics);
   }
 
   displays_ = new_displays;
 
   base::AutoReset<bool> resetter(&change_display_upon_host_resize_, false);
 
   // 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 (DisplayList::const_reverse_iterator iter = removed_displays.rbegin();
        iter != removed_displays.rend(); ++iter) {
     screen_ash_->NotifyDisplayRemoved(displays_.back());
     displays_.pop_back();
   }
   // Close the non desktop window here to avoid creating two compositor on
   // one display.
   if (!non_desktop_display_updater->enabled())
     non_desktop_display_updater.reset();
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
     screen_ash_->NotifyDisplayAdded(displays_[*iter]);
   }
   // Create the non destkop window after all displays are added so that
   // it can mirror the display newly added. This can happen when switching
   // from dock mode to software mirror mode.
   non_desktop_display_updater.reset();
-  for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
-       iter != changed_display_indices.end(); ++iter) {
-    screen_ash_->NotifyBoundsChanged(displays_[*iter]);
+  for (std::map<size_t, gfx::DisplayObserver::DisplayMetrics>::iterator iter =
+            display_changes.begin();
+       iter != display_changes.end(); ++iter) {
+    screen_ash_->NotifyMetricsChanged(displays_[iter->first], iter->second);
   }
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 
 #if defined(USE_X11) && defined(OS_CHROMEOS)
-  if (!changed_display_indices.empty() && base::SysInfo::IsRunningOnChromeOS())
+  if (!display_changes.empty() && base::SysInfo::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
 #endif
 }
 
 const gfx::Display& DisplayManager::GetDisplayAt(size_t index) const {
   DCHECK_LT(index, displays_.size());
   return displays_[index];
 }
 
 const gfx::Display& DisplayManager::GetPrimaryDisplayCandidate() const {
@@ skipping 123 matching lines @@
 
 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)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
-    screen_ash_->NotifyBoundsChanged(*display);
+    screen_ash_->NotifyMetricsChanged(*display,
+        gfx::DisplayObserver::DISPLAY_METRICS_BOUNDS);
     return true;
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowIfAny() {
   NonDesktopDisplayUpdater updater(this, delegate_);
 }
 
 void DisplayManager::CreateScreenForShutdown() const {
@@ skipping 148 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