Read compositor VSync information from platform, when possible

chrome/browser/ui/webui/options/chromeos/display_options_handler.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 "chrome/browser/ui/webui/options/chromeos/display_options_handler.h"
 
 #include <string>
 
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
@@ skipping 36 matching lines @@
 
   int64 display_id = gfx::Display::kInvalidDisplayID;
   if (!base::StringToInt64(id_value, &display_id)) {
     LOG(ERROR) << "Invalid display id: " << id_value;
     return gfx::Display::kInvalidDisplayID;
   }
 
   return display_id;
 }
 
-bool CompareResolution(ash::internal::Resolution r1,
-                       ash::internal::Resolution r2) {
-  return r1.size.GetArea() < r2.size.GetArea();
+bool CompareDisplayMode(ash::internal::DisplayMode d1,
+                        ash::internal::DisplayMode d2) {
+  if (d1.size.GetArea() == d2.size.GetArea())
+    return d1.refresh_rate < d2.refresh_rate;
+  return d1.size.GetArea() < d2.size.GetArea();
 }
 
 }  // namespace
 
 DisplayOptionsHandler::DisplayOptionsHandler() {
   ash::Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 DisplayOptionsHandler::~DisplayOptionsHandler() {
   ash::Shell::GetInstance()->display_controller()->RemoveObserver(this);
@@ skipping 110 matching lines @@
     js_display->SetInteger("x", bounds.x());
     js_display->SetInteger("y", bounds.y());
     js_display->SetInteger("width", bounds.width());
     js_display->SetInteger("height", bounds.height());
     js_display->SetString("name",
                           display_manager->GetDisplayNameForId(display.id()));
     js_display->SetBoolean("isPrimary", display.id() == primary_id);
     js_display->SetBoolean("isInternal", display.IsInternal());
     js_display->SetInteger("orientation",
                            static_cast<int>(display_info.rotation()));
-    std::vector<ash::internal::Resolution> resolutions;
+    std::vector<ash::internal::DisplayMode> display_modes;
     std::vector<float> ui_scales;
     if (display.IsInternal()) {
       ui_scales = DisplayManager::GetScalesForDisplay(display_info);
       gfx::SizeF base_size = display_info.bounds_in_native().size();
       base_size.Scale(1.0f / display_info.device_scale_factor());
       if (display_info.rotation() == gfx::Display::ROTATE_90 ||
           display_info.rotation() == gfx::Display::ROTATE_270) {
         float tmp = base_size.width();
         base_size.set_width(base_size.height());
         base_size.set_height(tmp);
       }
       for (size_t i = 0; i < ui_scales.size(); ++i) {
         gfx::SizeF new_size = base_size;
         new_size.Scale(ui_scales[i]);
-        resolutions.push_back(ash::internal::Resolution(
-            gfx::ToFlooredSize(new_size), false /* interlaced */));
+        display_modes.push_back(ash::internal::DisplayMode(
+            gfx::ToFlooredSize(new_size), -1.0f, false, false));
       }
     } else {
-      for (size_t i = 0; i < display_info.resolutions().size(); ++i)
-        resolutions.push_back(display_info.resolutions()[i]);
+      for (size_t i = 0; i < display_info.display_modes().size(); ++i)
+        display_modes.push_back(display_info.display_modes()[i]);
     }
-    std::sort(resolutions.begin(), resolutions.end(), CompareResolution);
+    std::sort(display_modes.begin(), display_modes.end(), CompareDisplayMode);
 
     base::ListValue* js_resolutions = new base::ListValue();
     gfx::Size current_size = display_info.bounds_in_native().size();
     gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
-    for (size_t i = 0; i < resolutions.size(); ++i) {
+    for (size_t i = 0; i < display_modes.size(); ++i) {
       base::DictionaryValue* resolution_info = new base::DictionaryValue();
-      gfx::Size resolution = resolutions[i].size;
+      gfx::Size resolution = display_modes[i].size;
       if (!ui_scales.empty()) {
         resolution_info->SetDouble("scale", ui_scales[i]);
         if (ui_scales[i] == 1.0f)
           resolution_info->SetBoolean("isBest", true);
         resolution_info->SetBoolean(
             "selected", display_info.configured_ui_scale() == ui_scales[i]);
       } else {
         // Picks the largest one as the "best", which is the last element
-        // because |resolutions| is sorted by its area.
-        if (i == resolutions.size() - 1)
+        // because |display_modes| is sorted by its area.
+        if (i == display_modes.size() - 1)
           resolution_info->SetBoolean("isBest", true);
         resolution_info->SetBoolean("selected", (resolution == current_size));
         resolution.Enlarge(
             -current_overscan.width(), -current_overscan.height());
       }
       resolution_info->SetInteger("width", resolution.width());
       resolution_info->SetInteger("height", resolution.height());
+      if (display_modes[i].refresh_rate > 0.0f) {
+        resolution_info->SetDouble("refreshRate",
+                                   display_modes[i].refresh_rate);
+      }
       js_resolutions->Append(resolution_info);
     }
     js_display->Set("resolutions", js_resolutions);
     js_displays.Append(js_display);
   }
 
   scoped_ptr<base::Value> layout_value(base::Value::CreateNullValue());
   scoped_ptr<base::Value> offset_value(base::Value::CreateNullValue());
   if (display_manager->GetNumDisplays() > 1) {
     const ash::DisplayLayout layout =
@@ skipping 98 matching lines @@
   }
 
   const ash::internal::DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display_id);
   gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
   gfx::Size new_resolution = gfx::ToFlooredSize(gfx::SizeF(width, height));
   new_resolution.Enlarge(current_overscan.width(), current_overscan.height());
   gfx::Size old_resolution = display_info.bounds_in_native().size();
   bool has_new_resolution = false;
   bool has_old_resolution = false;
-  for (size_t i = 0; i < display_info.resolutions().size(); ++i) {
-    ash::internal::Resolution resolution = display_info.resolutions()[i];
-    if (resolution.size == new_resolution)
+  for (size_t i = 0; i < display_info.display_modes().size(); ++i) {
+    ash::internal::DisplayMode display_mode = display_info.display_modes()[i];
+    if (display_mode.size == new_resolution)
       has_new_resolution = true;
-    if (resolution.size == old_resolution)
+    if (display_mode.size == old_resolution)
       has_old_resolution = true;
   }
   if (!has_new_resolution) {
     LOG(ERROR) << "No new resolution " << new_resolution.ToString()
                << " is found in the display info " << display_info.ToString();
     return;
   }
   if (!has_old_resolution) {
     LOG(ERROR) << "No old resolution " << old_resolution.ToString()
                << " is found in the display info " << display_info.ToString();
@@ skipping 26 matching lines @@
   else if (rotation_value == "270")
     new_rotation = gfx::Display::ROTATE_270;
   else if (rotation_value != "0")
     LOG(ERROR) << "Invalid rotation: " << rotation_value << " Falls back to 0";
 
   GetDisplayManager()->SetDisplayRotation(display_id, new_rotation);
 }
 
 }  // namespace options
 }  // namespace chromeos