Read compositor VSync information from platform, when possible

chrome/browser/chromeos/display/display_preferences.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/chromeos/display/display_preferences.h"
 
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/display_pref_util.h"
 #include "ash/display/resolution_notification_controller.h"
@@ skipping 117 matching lines @@
 
     int rotation_value = 0;
     if (dict_value->GetInteger("rotation", &rotation_value)) {
       rotation = static_cast<gfx::Display::Rotation>(rotation_value);
     }
     int ui_scale_value = 0;
     if (dict_value->GetInteger("ui-scale", &ui_scale_value))
       ui_scale = static_cast<float>(ui_scale_value) / 1000.0f;
 
     int width = 0, height = 0;
+    double refresh_rate;
     dict_value->GetInteger("width", &width);
     dict_value->GetInteger("height", &height);
+    dict_value->GetDouble("refresh-rate", &refresh_rate);

[oshima, 2014/01/27 18:53:22]

Unless you want to use this to select output mode, you don't have to save this
in persistent state.

[sheu, 2014/01/28 21:30:42]

My problem here is that RegisterDisplayProperty creates a new Resolution and
sets the display to that resolution.  If we don't provide a refresh_rate, then
it should default to 0 Hz and will stay there until the next time native modes
are passed in or SetDisplayResolution is called.  So until then we don't have
refresh rate information.

What would you suggest instead of storing the refresh rate?

[oshima, 2014/01/28 22:17:08]

I believe your problem was that you didn't add the mode in
DisplayManager::OnNativeDisplayChanged. Please see my comment there.

You should also provide some rate as default because chrome can boot with zero
displays. (in which case, it'll use the same display info created from empty
spec)

[sheu, 2014/01/29 00:14:10]

I've added a default, but I'm not sure what you mean about adding the mode.  I
think I already did -- see comment there.

A related question: RegisterDisplayProperty() seems just to be a way to
short-circuit the native display detection and insert a modeline into the
DisplayManager.  Is this the correct interpretation?

[oshima, 2014/01/29 01:15:26]

Maybe I misread the code, but if you indeed added it, then you shouldn't have to
store the refresh rate. Here is roughly what is happening.

1) RegisterDisplayProperty sets the display mode stored in the previous run.
2) In OutputConfigrator::Start, it will read the selected resolution from
DisplayManager and
  configure the displays.
3) Which will call DisplayManager::OnNativeDisplayChanged, which will update the
   display_mode_ with the correct refresh rate.
4) DisplayController creates a root window and updates the refresh rate using
  the DisplayMode stored in DisplayManager.

If it's not working, then something else must be broken.
I'm not sure what you mean by "short-circuit". This is necessary to properly
restore
the display settings (from previous run) when chrome starts. That is, you need
to know
which resolution chrome should configure the display to when it starts.

     gfx::Size resolution_in_pixels(width, height);
 
     gfx::Insets insets;
     if (ValueToInsets(*dict_value, &insets))
       insets_to_set = &insets;
     GetDisplayManager()->RegisterDisplayProperty(id,
                                                  rotation,
                                                  ui_scale,
                                                  insets_to_set,
-                                                 resolution_in_pixels);
+                                                 resolution_in_pixels,
+                                                 refresh_rate);
   }
 }
 
 void StoreDisplayLayoutPref(const ash::DisplayIdPair& pair,
                             const ash::DisplayLayout& display_layout) {
   std::string name =
       base::Int64ToString(pair.first) + "," + base::Int64ToString(pair.second);
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, prefs::kSecondaryDisplays);
@@ skipping 33 matching lines @@
     int64 id = display.id();
     ash::internal::DisplayInfo info = display_manager->GetDisplayInfo(id);
 
     scoped_ptr<base::DictionaryValue> property_value(
         new base::DictionaryValue());
     property_value->SetInteger("rotation", static_cast<int>(info.rotation()));
     property_value->SetInteger(
         "ui-scale",
         static_cast<int>(info.configured_ui_scale() * 1000));
     gfx::Size resolution;
+    float refresh_rate;
     if (!display.IsInternal() &&
-        display_manager->GetSelectedResolutionForDisplayId(id, &resolution)) {
+        display_manager->GetSelectedResolutionForDisplayId(
+            id, &resolution, &refresh_rate)) {
       property_value->SetInteger("width", resolution.width());
       property_value->SetInteger("height", resolution.height());
+      property_value->SetDouble("refresh-rate", refresh_rate);
     }
 
     if (!info.overscan_insets_in_dip().empty())
       InsetsToValue(info.overscan_insets_in_dip(), property_value.get());
     pref_data->Set(base::Int64ToString(id), property_value.release());
   }
 }
 
 typedef std::map<chromeos::DisplayPowerState, std::string>
     DisplayPowerStateToStringMap;
@@ skipping 83 matching lines @@
                                    const ash::DisplayLayout& layout) {
   StoreDisplayLayoutPref(std::make_pair(id1, id2), layout);
 }
 
 // Stores the given |power_state|.
 void StoreDisplayPowerStateForTest(DisplayPowerState power_state) {
   StoreDisplayPowerState(power_state);
 }
 
 }  // namespace chromeos