Read compositor VSync information from platform, when possible

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 434 matching lines @@
   const std::vector<Resolution>& resolutions = display_info.resolutions();
   DCHECK_NE(0u, resolutions.size());
   std::vector<Resolution>::const_iterator iter =
       std::find_if(resolutions.begin(),
                    resolutions.end(),
                    ResolutionMatcher(resolution));
   if (iter == resolutions.end()) {
     LOG(WARNING) << "Unsupported resolution was requested:"
                  << resolution.ToString();
     return;
-  } else if (iter == resolutions.begin()) {
-    // The best resolution was set, so forget it.
-    resolutions_.erase(display_id);
-  } else {
-    resolutions_[display_id] = resolution;
   }
+  resolutions_[display_id] = *iter;
 #if defined(OS_CHROMEOS) && defined(USE_X11)
   if (base::SysInfo::IsRunningOnChromeOS())
     Shell::GetInstance()->output_configurator()->ScheduleConfigureOutputs();
 #endif
 }
 
 void DisplayManager::RegisterDisplayProperty(
     int64 display_id,
     gfx::Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets,
-    const gfx::Size& resolution_in_pixels) {
+    const gfx::Size& resolution_in_pixels,
+    float refresh_rate) {
   if (display_info_.find(display_id) == display_info_.end()) {
     display_info_[display_id] =
         DisplayInfo(display_id, std::string(""), false);
   }
 
   display_info_[display_id].set_rotation(rotation);
   // Just in case the preference file was corrupted.
   if (0.5f <= ui_scale && ui_scale <= 2.0f)
     display_info_[display_id].set_configured_ui_scale(ui_scale);
   if (overscan_insets)
     display_info_[display_id].SetOverscanInsets(*overscan_insets);
-  if (!resolution_in_pixels.IsEmpty())
-    resolutions_[display_id] = resolution_in_pixels;
+  if (!resolution_in_pixels.IsEmpty()) {
+    resolutions_[display_id] =
+        Resolution(resolution_in_pixels, refresh_rate, false);
+  }
 }
 
 bool DisplayManager::GetSelectedResolutionForDisplayId(
     int64 id,
-    gfx::Size* resolution_out) const {
-  std::map<int64, gfx::Size>::const_iterator iter =
-      resolutions_.find(id);
+    gfx::Size* resolution_out,
+    float* refresh_rate_out) const {
+  std::map<int64, Resolution>::const_iterator iter = resolutions_.find(id);
   if (iter == resolutions_.end())
     return false;
-  *resolution_out = iter->second;
+  *resolution_out = iter->second.size;
+  *refresh_rate_out = iter->second.refresh_rate;
   return true;
 }
 
 bool DisplayManager::IsDisplayUIScalingEnabled() const {
   return GetDisplayIdForUIScaling() != gfx::Display::kInvalidDisplayID;
 }
 
 gfx::Insets DisplayManager::GetOverscanInsets(int64 display_id) const {
   std::map<int64, DisplayInfo>::const_iterator it =
       display_info_.find(display_id);
@@ skipping 62 matching lines @@
     const gfx::Size& resolution = iter->bounds_in_native().size();
     const std::vector<Resolution>& resolutions = iter->resolutions();
     // This is empty the displays are initialized from InitFromCommandLine.
     if (!resolutions.size())
       continue;
     std::vector<Resolution>::const_iterator resolution_iter =
         std::find_if(resolutions.begin(),
                      resolutions.end(),
                      ResolutionMatcher(resolution));
     // Update the actual resolution selected as the resolution request may fail.
-    if (resolution_iter == resolutions.begin())
+    if (resolution_iter != resolutions.end())
+      resolutions_[iter->id()] = *resolution_iter;
+    else
       resolutions_.erase(iter->id());
-    else if (resolutions_.find(iter->id()) != resolutions_.end())
-      resolutions_[iter->id()] = resolution;
   }
   if (HasInternalDisplay() &&
       !internal_display_connected &&
       display_info_.find(gfx::Display::InternalDisplayId()) ==
       display_info_.end()) {
     DisplayInfo internal_display_info(
         gfx::Display::InternalDisplayId(),
         l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME),
         false  /*Internal display must not have overscan */);
     internal_display_info.SetBounds(gfx::Rect(0, 0, 800, 600));
@@ skipping 60 matching lines @@
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (new_info_iter != new_display_info_list.end() &&
         non_desktop_display_id == new_info_iter->id()) {
       DisplayInfo info = *new_info_iter;
       info.SetOverscanInsets(gfx::Insets());
       InsertAndUpdateDisplayInfo(info);
       non_desktop_display_ =
           CreateDisplayFromDisplayInfoById(non_desktop_display_id);
       ++new_info_iter;
-      // Remove existing external dispaly if it is going to be used as
+      // Remove existing external display if it is going to be used as
       // non desktop.
       if (curr_iter != displays_.end() &&
           curr_iter->id() == non_desktop_display_id) {
         removed_displays.push_back(*curr_iter);
         ++curr_iter;
       }
       continue;
     }
 
     if (curr_iter == displays_.end()) {
@@ skipping 408 matching lines @@
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace internal
 }  // namespace ash