Read compositor VSync information from platform, when possible

ash/display/display_info.h

 // Copyright (c) 2013 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.
 
 #ifndef ASH_DISPLAY_DISPLAY_INFO_H_
 #define ASH_DISPLAY_DISPLAY_INFO_H_
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/rect.h"
 
 namespace ash {
 namespace internal {
 
-// A struct that represents the display's resolution and
-// interlaced info.
-struct ASH_EXPORT Resolution {
-  Resolution(const gfx::Size& size, bool interlaced);
+// A struct that represents the display's mode info.
+struct ASH_EXPORT DisplayMode {
+  DisplayMode();
+  DisplayMode(const gfx::Size& size,
+              float refresh_rate,
+              bool interlaced,
+              bool native);
 
-  gfx::Size size;
-  bool interlaced;
+  gfx::Size size;      // Physical pixel size of the display.
+  float refresh_rate;  // Refresh rate of the display, in Hz.
+  bool interlaced;     // True if mode is interlaced.
+  bool native;         // True if mode is native mode of the display.
 };
 
 // DisplayInfo contains metadata for each display. This is used to
 // create |gfx::Display| as well as to maintain extra infomation
 // to manage displays in ash environment.
 // This class is intentionally made copiable.
 class ASH_EXPORT DisplayInfo {
  public:
   // Creates a DisplayInfo from string spec. 100+200-1440x800 creates display
   // whose size is 1440x800 at the location (100, 200) in host coordinates.
   // The format is
   //
   // [origin-]widthxheight[*device_scale_factor][#resolutions list]
   //     [/<properties>][@ui-scale]
   //
   // where [] are optional:
   // - |origin| is given in x+y- format.
   // - |device_scale_factor| is either 2 or 1 (or empty).
   // - properties can combination of 'o', which adds default overscan insets
   //   (5%), and one rotation property where 'r' is 90 degree clock-wise
   //   (to the 'r'ight) 'u' is 180 degrees ('u'pside-down) and 'l' is
   //   270 degrees (to the 'l'eft).
   // - ui-scale is floating value, e.g. @1.5 or @1.25.
   // - |resolution list| is the list of size that is given in
-  //   |width x height| separated by '|'.
+  //   |width x height [% refresh_rate]| separated by '|'.
   //
   // A couple of examples:
   // "100x100"
   //      100x100 window at 0,0 origin. 1x device scale factor. no overscan.
   //      no rotation. 1.0 ui scale.
   // "5+5-300x200*2"
   //      300x200 window at 5,5 origin. 2x device scale factor.
   //      no overscan, no rotation. 1.0 ui scale.
   // "300x200/ol"
   //      300x200 window at 0,0 origin. 1x device scale factor.
   //      with 5% overscan. rotated to left (90 degree counter clockwise).
   //      1.0 ui scale.
   // "10+20-300x200/u@1.5"
   //      300x200 window at 10,20 origin. 1x device scale factor.
   //      no overscan. flipped upside-down (180 degree) and 1.5 ui scale.
-  // "200x100#300x200|200x100|100x100"
+  // "200x100#300x200|200x100%59.0|100x100%60"
   //      200x100 window at 0,0 origin, with 3 possible resolutions,
-  //      300x200, 200x100 and 100x100.
+  //      300x200, 200x100 at 59 Hz, and 100x100 at 60 Hz.
   static DisplayInfo CreateFromSpec(const std::string& spec);
 
   // Creates a DisplayInfo from string spec using given |id|.
   static DisplayInfo CreateFromSpecWithID(const std::string& spec,
                                           int64 id);
 
   DisplayInfo();
   DisplayInfo(int64 id, const std::string& name, bool has_overscan);
   ~DisplayInfo();
 
@@ skipping 56 matching lines @@
   // and rotation settings.
   void UpdateDisplaySize();
 
   // Sets/Clears the overscan insets.
   void SetOverscanInsets(const gfx::Insets& insets_in_dip);
   gfx::Insets GetOverscanInsetsInPixel() const;
 
   void set_native(bool native) { native_ = native; }
   bool native() const { return native_; }
 
-  const std::vector<Resolution>& resolutions() const {
-    return resolutions_;
+  const std::vector<DisplayMode>& display_modes() const {
+    return display_modes_;
   }
-  void set_resolutions(std::vector<Resolution>& resolution) {
-    resolutions_.swap(resolution);
+  void set_display_modes(std::vector<DisplayMode>& display_modes) {
+    display_modes_.swap(display_modes);
   }
 
-  // Returns a string representation of the DisplayInfo
-  // excluding resolutions.
+  // Returns a string representation of the DisplayInfo, excluding display
+  // modes.
   std::string ToString() const;
 
-  // Returns a string representation of the DisplayInfo
-  // including resolutions.
+  // Returns a string representation of the DisplayInfo, including display
+  // modes.
   std::string ToFullString() const;
 
  private:
   int64 id_;
   std::string name_;
   bool has_overscan_;
   gfx::Display::Rotation rotation_;
   gfx::Display::TouchSupport touch_support_;
 
   // This specifies the device's pixel density. (For example, a
@@ skipping 13 matching lines @@
   // shrink) the desktop over the native display resolution (useful in
   // HighDPI display).  Note that this should not be confused with the
   // device scale factor, which specifies the pixel density of the
   // display. The actuall scale value to be used depends on the device
   // scale factor.  See |GetEffectiveScaleFactor()|.
   float configured_ui_scale_;
 
   // True if this comes from native platform (DisplayChangeObserver).
   bool native_;
 
-  // The list of resolutions supported by this display.
-  std::vector<Resolution> resolutions_;
+  // The list of modes supported by this display.
+  std::vector<DisplayMode> display_modes_;
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  //  ASH_DISPLAY_DISPLAY_INFO_H_