Add display refresh rate to about://gpu on Windows

Some gpu bugs are related to the monitor refresh rate. Adding this display
information will help us on gpu debugging.

This CL is for Windows only.

Bug: 964095
Change-Id: Ic00471897f0f7c655dbe29e3b33b5b7782cab6b3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1621328Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Robert Liao <robliao@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Commit-Queue: Maggie Chen <magchen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#662910}

content/browser/gpu/gpu_internals_ui.cc

@@ -383,6 +383,11 @@ std::unique_ptr<base::ListValue> getDisplayInfo() {
         base::NumberToString(display.depth_per_component())));
     display_info->Append(NewDescriptionValuePair(
         "Bits per pixel", base::NumberToString(display.color_depth())));
+    if (display.display_frequency()) {
+      display_info->Append(NewDescriptionValuePair(
+          "Refresh Rate in Hz",
+          base::NumberToString(display.display_frequency())));
+    }
   }
   return display_info;
 }

content/browser/renderer_host/display_util.cc

@@ -24,6 +24,7 @@ void DisplayUtil::DisplayToScreenInfo(ScreenInfo* screen_info,
   screen_info->depth = display.color_depth();
   screen_info->depth_per_component = display.depth_per_component();
   screen_info->is_monochrome = display.is_monochrome();
+  screen_info->display_frequency = display.display_frequency();
 
   screen_info->orientation_angle = display.RotationAsDegree();
 #if defined(USE_AURA)

content/common/frame_messages.h

@@ -356,6 +356,7 @@ IPC_STRUCT_TRAITS_BEGIN(content::ScreenInfo)
   IPC_STRUCT_TRAITS_MEMBER(depth)
   IPC_STRUCT_TRAITS_MEMBER(depth_per_component)
   IPC_STRUCT_TRAITS_MEMBER(is_monochrome)
+  IPC_STRUCT_TRAITS_MEMBER(display_frequency)
   IPC_STRUCT_TRAITS_MEMBER(rect)
   IPC_STRUCT_TRAITS_MEMBER(available_rect)
   IPC_STRUCT_TRAITS_MEMBER(orientation_type)

content/public/common/screen_info.cc

@@ -14,7 +14,8 @@ bool ScreenInfo::operator==(const ScreenInfo& other) const {
   return device_scale_factor == other.device_scale_factor &&
          color_space == other.color_space && depth == other.depth &&
          depth_per_component == other.depth_per_component &&
-         is_monochrome == other.is_monochrome && rect == other.rect &&
+         is_monochrome == other.is_monochrome &&
+         display_frequency == other.display_frequency && rect == other.rect &&
          available_rect == other.available_rect &&
          orientation_type == other.orientation_type &&
          orientation_angle == other.orientation_angle;

content/public/common/screen_info.h

@@ -38,6 +38,10 @@ struct CONTENT_EXPORT ScreenInfo {
     // This can be true for black and white printers
     bool is_monochrome = false;
 
+    // The display frequency in Hz of the monitor. Set to 0 if it fails in the
+    // monitor frequency query.
+    int display_frequency = 0;
+
     // The display monitor rectangle in virtual-screen coordinates. Note that
     // this may be negative.
     gfx::Rect rect;

ui/display/display.cc

@@ -366,7 +366,8 @@ bool Display::operator==(const Display& rhs) const {
          maximum_cursor_size_ == rhs.maximum_cursor_size_ &&
          color_space_ == rhs.color_space_ && color_depth_ == rhs.color_depth_ &&
          depth_per_component_ == rhs.depth_per_component_ &&
-         is_monochrome_ == rhs.is_monochrome_;
+         is_monochrome_ == rhs.is_monochrome_ &&
+         display_frequency_ == rhs.display_frequency_;
 }
 
 }  // namespace display

ui/display/display.h

@@ -255,6 +255,12 @@ class DISPLAY_EXPORT Display final {
   bool is_monochrome() const { return is_monochrome_; }
   void set_is_monochrome(bool is_monochrome) { is_monochrome_ = is_monochrome; }
 
+  // The display frequency of the monitor.
+  int display_frequency() const { return display_frequency_; }
+  void set_display_frequency(int display_frequency) {
+    display_frequency_ = display_frequency;
+  }
+
   bool operator==(const Display& rhs) const;
   bool operator!=(const Display& rhs) const { return !(*this == rhs); }
 
@@ -279,6 +285,7 @@ class DISPLAY_EXPORT Display final {
   int color_depth_;
   int depth_per_component_;
   bool is_monochrome_ = false;
+  int display_frequency_ = 0;
 };
 
 }  // namespace display

ui/display/display_unittest.cc

@@ -90,4 +90,14 @@ TEST(DisplayTest, DisplayHDRValues) {
   EXPECT_EQ(8, display.depth_per_component());
 }
 
+TEST(DisplayTest, DisplayFrequency) {
+  Display display(0, gfx::Rect(0, 0, 100, 100));
+
+  display.set_display_frequency(60);
+  EXPECT_EQ(60, display.display_frequency());
+
+  display.set_display_frequency(120);
+  EXPECT_EQ(120, display.display_frequency());
+}
+
 }  // namespace display

ui/display/mojo/display.mojom

@@ -42,4 +42,5 @@ struct Display {
   int32 color_depth;
   int32 depth_per_component;
   bool is_monochrome;
+  int32 display_frequency;
 };

ui/display/mojo/display_struct_traits.cc

@@ -143,6 +143,7 @@ bool StructTraits<display::mojom::DisplayDataView, display::Display>::Read(
   out->set_color_depth(data.color_depth());
   out->set_depth_per_component(data.depth_per_component());
   out->set_is_monochrome(data.is_monochrome());
+  out->set_display_frequency(data.display_frequency());
 
   return true;
 }

ui/display/mojo/display_struct_traits.h

@@ -86,6 +86,10 @@ struct StructTraits<display::mojom::DisplayDataView, display::Display> {
     return display.is_monochrome();
   }
 
+  static int32_t display_frequency(const display::Display& display) {
+    return display.display_frequency();
+  }
+
   static bool Read(display::mojom::DisplayDataView data, display::Display* out);
 };
 

ui/display/mojo/display_struct_traits_unittest.cc

@@ -46,6 +46,7 @@ void CheckDisplaysEqual(const Display& input, const Display& output) {
   EXPECT_EQ(input.color_depth(), output.color_depth());
   EXPECT_EQ(input.depth_per_component(), output.depth_per_component());
   EXPECT_EQ(input.is_monochrome(), output.is_monochrome());
+  EXPECT_EQ(input.display_frequency(), output.display_frequency());
 }
 
 void CheckDisplayLayoutsEqual(const DisplayLayout& input,
@@ -140,6 +141,7 @@ TEST(DisplayStructTraitsTest, SetAllDisplayValues) {
   input.set_color_depth(input.color_depth() + 1);
   input.set_depth_per_component(input.depth_per_component() + 1);
   input.set_is_monochrome(!input.is_monochrome());
+  input.set_display_frequency(input.display_frequency() + 1);
 
   Display output;
   SerializeAndDeserialize<mojom::Display>(input, &output);

ui/display/win/display_info.cc

@@ -8,52 +8,22 @@
 #include "base/strings/utf_string_conversions.h"
 
 namespace display {
-namespace {
-
-Display::Rotation GetRotationForDevice(const wchar_t* device_name) {
-  DEVMODE mode;
-  ::ZeroMemory(&mode, sizeof(mode));
-  mode.dmSize = sizeof(mode);
-  mode.dmDriverExtra = 0;
-  if (::EnumDisplaySettings(device_name, ENUM_CURRENT_SETTINGS, &mode)) {
-    switch (mode.dmDisplayOrientation) {
-    case DMDO_DEFAULT:
-      return Display::ROTATE_0;
-    case DMDO_90:
-      return Display::ROTATE_90;
-    case DMDO_180:
-      return Display::ROTATE_180;
-    case DMDO_270:
-      return Display::ROTATE_270;
-    default:
-      NOTREACHED();
-    }
-  }
-  return Display::ROTATE_0;
-}
-
-}  // namespace
-
 namespace win {
 
-DisplayInfo::DisplayInfo(const MONITORINFOEX& monitor_info,
-                         float device_scale_factor,
-                         float sdr_white_level)
-    : DisplayInfo(monitor_info,
-                  device_scale_factor,
-                  sdr_white_level,
-                  GetRotationForDevice(monitor_info.szDevice)) {}
-
 DisplayInfo::DisplayInfo(const MONITORINFOEX& monitor_info,
                          float device_scale_factor,
                          float sdr_white_level,
-                         Display::Rotation rotation)
+                         Display::Rotation rotation,
+                         int display_frequency)
     : id_(DeviceIdFromDeviceName(monitor_info.szDevice)),
       rotation_(rotation),
       screen_rect_(monitor_info.rcMonitor),
       screen_work_rect_(monitor_info.rcWork),
       device_scale_factor_(device_scale_factor),
-      sdr_white_level_(sdr_white_level) {}
+      sdr_white_level_(sdr_white_level),
+      display_frequency_(display_frequency) {}
+
+DisplayInfo::~DisplayInfo() = default;
 
 // static
 int64_t DisplayInfo::DeviceIdFromDeviceName(const wchar_t* device_name) {

ui/display/win/display_info.h

@@ -17,13 +17,12 @@ namespace win {
 // Gathers the parameters necessary to create a win::ScreenWinDisplay.
 class DISPLAY_EXPORT DisplayInfo final {
  public:
-  DisplayInfo(const MONITORINFOEX& monitor_info,
-              float device_scale_factor,
-              float sdr_white_level);
   DisplayInfo(const MONITORINFOEX& monitor_info,
               float device_scale_factor,
               float sdr_white_level,
-              Display::Rotation rotation);
+              Display::Rotation rotation,
+              int display_frequency);
+  ~DisplayInfo();
 
   static int64_t DeviceIdFromDeviceName(const wchar_t* device_name);
 
@@ -33,6 +32,7 @@ class DISPLAY_EXPORT DisplayInfo final {
   const gfx::Rect& screen_work_rect() const { return screen_work_rect_; }
   float device_scale_factor() const { return device_scale_factor_; }
   float sdr_white_level() const { return sdr_white_level_; }
+  int display_frequency() const { return display_frequency_; }
 
  private:
   int64_t id_;
@@ -41,6 +41,7 @@ class DISPLAY_EXPORT DisplayInfo final {
   gfx::Rect screen_work_rect_;
   float device_scale_factor_;
   float sdr_white_level_;
+  int display_frequency_;
 };
 
 }  // namespace win

ui/display/win/scaling_util_unittest.cc

@@ -20,7 +20,7 @@ DisplayInfo CreateDisplayInfo(int x, int y, int width, int height,
   MONITORINFOEX monitor_info = CreateMonitorInfo(gfx::Rect(x, y, width, height),
                                                  gfx::Rect(x, y, width, height),
                                                  kFakeDisplayName);
-  return DisplayInfo(monitor_info, scale_factor, 1.0f);
+  return DisplayInfo(monitor_info, scale_factor, 1.0f, Display::ROTATE_0, 60);
 }
 
 ::testing::AssertionResult AssertOffsetsEqual(

ui/display/win/screen_win.cc

@@ -152,6 +152,34 @@ float GetMonitorSDRWhiteLevel(HMONITOR monitor) {
   return ret;
 }
 
+void GetDisplaySettingsForDevice(const wchar_t* device_name,
+                                 Display::Rotation* rotation,
+                                 int* frequency) {
+  *rotation = Display::ROTATE_0;
+  *frequency = 0;
+  DEVMODE mode = {};
+  mode.dmSize = sizeof(mode);
+  if (::EnumDisplaySettings(device_name, ENUM_CURRENT_SETTINGS, &mode)) {
+    switch (mode.dmDisplayOrientation) {
+      case DMDO_DEFAULT:
+        *rotation = Display::ROTATE_0;
+        break;
+      case DMDO_90:
+        *rotation = Display::ROTATE_90;
+        break;
+      case DMDO_180:
+        *rotation = Display::ROTATE_180;
+        break;
+      case DMDO_270:
+        *rotation = Display::ROTATE_270;
+        break;
+      default:
+        NOTREACHED();
+    }
+    *frequency = mode.dmDisplayFrequency;
+  }
+}
+
 std::vector<DisplayInfo> FindAndRemoveTouchingDisplayInfos(
     const DisplayInfo& ref_display_info,
     std::vector<DisplayInfo>* display_infos) {
@@ -179,6 +207,7 @@ Display CreateDisplayFromDisplayInfo(const DisplayInfo& display_info,
   display.set_bounds(gfx::ScaleToEnclosingRect(display_info.screen_rect(),
                      1.0f / scale_factor));
   display.set_rotation(display_info.rotation());
+  display.set_display_frequency(display_info.display_frequency());
   if (!Display::HasForceDisplayColorProfile()) {
     if (hdr_enabled) {
       // It doesn't matter what HDR color space we set since UI compositor will
@@ -266,8 +295,7 @@ std::vector<Display> ScreenWinDisplaysToDisplays(
 }
 
 MONITORINFOEX MonitorInfoFromHMONITOR(HMONITOR monitor) {
-  MONITORINFOEX monitor_info;
-  ::ZeroMemory(&monitor_info, sizeof(monitor_info));
+  MONITORINFOEX monitor_info = {};
   monitor_info.cbSize = sizeof(monitor_info);
   ::GetMonitorInfo(monitor, &monitor_info);
   return monitor_info;
@@ -280,9 +308,15 @@ BOOL CALLBACK EnumMonitorForDisplayInfoCallback(HMONITOR monitor,
   std::vector<DisplayInfo>* display_infos =
       reinterpret_cast<std::vector<DisplayInfo>*>(data);
   DCHECK(display_infos);
-  display_infos->push_back(DisplayInfo(MonitorInfoFromHMONITOR(monitor),
-                                       GetMonitorScaleFactor(monitor),
-                                       GetMonitorSDRWhiteLevel(monitor)));
+
+  Display::Rotation rotation;
+  int display_frequency;
+  MONITORINFOEX monitor_info = MonitorInfoFromHMONITOR(monitor);
+  GetDisplaySettingsForDevice(monitor_info.szDevice, &rotation,
+                              &display_frequency);
+  display_infos->push_back(DisplayInfo(
+      monitor_info, GetMonitorScaleFactor(monitor),
+      GetMonitorSDRWhiteLevel(monitor), rotation, display_frequency));
   return TRUE;
 }
 

ui/display/win/screen_win_display.cc

@@ -21,6 +21,7 @@ Display CreateDisplayFromDisplayInfo(const DisplayInfo& display_info) {
   display.set_bounds(gfx::ScaleToEnclosingRect(display_info.screen_rect(),
                      1.0f / scale_factor));
   display.set_rotation(display_info.rotation());
+  display.set_display_frequency(display_info.display_frequency());
   return display;
 }
 

ui/display/win/screen_win_unittest.cc

@@ -157,7 +157,7 @@ class TestScreenWinManager final : public TestScreenWinInitializer {
         win::test::CreateMonitorInfo(pixel_bounds, pixel_work, device_name);
     monitor_infos_.push_back(monitor_info);
     display_infos_.push_back(DisplayInfo(monitor_info, device_scale_factor,
-                                         Display::ROTATE_0));
+                                         1.0f, Display::ROTATE_0, 60));
   }
 
   HWND CreateFakeHwnd(const gfx::Rect& bounds) override {