Add ScreenWin::GetSystemMetricsForHwnd

ui/display/win/screen_win_unittest.cc

 // Copyright 2015 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 "ui/display/win/screen_win.h"
 
 #include <windows.h>
 #include <inttypes.h>
 #include <stddef.h>
 
@@ skipping 103 matching lines @@
       }
     }
     NOTREACHED();
     return monitor_infos_[0];
   }
 
   HWND GetRootWindow(HWND hwnd) const override {
     return hwnd;
   }
 
+  int GetSystemMetrics(int metric) const override {
+    return metric;
+  }
+
   std::vector<MONITORINFOEX> monitor_infos_;
   std::unordered_map<HWND, gfx::Rect> hwnd_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreenWin);
 };
 
 Screen* GetScreen() {
   return Screen::GetScreen();
 }
 
@@ skipping 184 matching lines @@
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(hwnd, size));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, DIPToScreenSize) {
   HWND hwnd = GetFakeHwnd();
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::DIPToScreenSize(hwnd, size));
 }
 
+TEST_F(ScreenWinTestSingleDisplay1x, GetSystemMetricsForHwnd) {
+  HWND hwnd = GetFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay1x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(1u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1200), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1100), displays[0].work_area());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetNumDisplays) {
   EXPECT_EQ(1, GetScreen()->GetNumDisplays());
 }
@@ skipping 135 matching lines @@
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(hwnd, size));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_25x, DIPToScreenSize) {
   HWND hwnd = GetFakeHwnd();
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::DIPToScreenSize(hwnd, size));
 }
 
+TEST_F(ScreenWinTestSingleDisplay1_25x, GetSystemMetricsForHwnd) {
+  HWND hwnd = GetFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(1u, displays.size());
   // On Windows, scale factors of 1.25 or lower are clamped to 1.0.
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1200), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1100), displays[0].work_area());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayNearestWindow) {
   Screen* screen = GetScreen();
@@ skipping 120 matching lines @@
 TEST_F(ScreenWinTestSingleDisplay1_5x, ScreenToDIPSize) {
   EXPECT_EQ(gfx::Size(28, 88),
             ScreenWin::ScreenToDIPSize(GetFakeHwnd(), gfx::Size(42, 131)));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_5x, DIPToScreenSize) {
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(GetFakeHwnd(), gfx::Size(28, 88)));
 }
 
+TEST_F(ScreenWinTestSingleDisplay1_5x, GetSystemMetricsForHwnd) {
+  HWND hwnd = GetFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(1u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 1280, 800), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1280, 734), displays[0].work_area());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayNearestWindow) {
   Screen* screen = GetScreen();
   gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
@@ skipping 119 matching lines @@
 TEST_F(ScreenWinTestSingleDisplay2x, ScreenToDIPSize) {
   EXPECT_EQ(gfx::Size(21, 66),
             ScreenWin::ScreenToDIPSize(GetFakeHwnd(), gfx::Size(42, 131)));
 }
 
 TEST_F(ScreenWinTestSingleDisplay2x, DIPToScreenSize) {
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(GetFakeHwnd(), gfx::Size(21, 66)));
 }
 
+TEST_F(ScreenWinTestSingleDisplay2x, GetSystemMetricsForHwnd) {
+  HWND hwnd = GetFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(1u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 960, 600), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 960, 550), displays[0].work_area());
 }
 
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayNearestWindow) {
   Screen* screen = GetScreen();
   gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
@@ skipping 180 matching lines @@
 
 TEST_F(ScreenWinTestTwoDisplays1x, DIPToScreenSize) {
   HWND left_hwnd = GetLeftFakeHwnd();
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::DIPToScreenSize(left_hwnd, size));
 
   HWND right_hwnd = GetRightFakeHwnd();
   EXPECT_EQ(size, ScreenWin::DIPToScreenSize(right_hwnd, size));
 }
 
+TEST_F(ScreenWinTestTwoDisplays1x, GetSystemMetricsForHwnd) {
+  HWND left_hwnd = GetLeftFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
+  HWND right_hwnd = GetRightFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays1x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(2u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1200), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1100), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(1920, 0, 800, 600), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(1920, 0, 800, 600), displays[1].work_area());
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetNumDisplays) {
@@ skipping 228 matching lines @@
 TEST_F(ScreenWinTestTwoDisplays2x, DIPToScreenSize) {
   HWND left_hwnd = GetLeftFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(left_hwnd, gfx::Size(21, 66)));
 
   HWND right_hwnd = GetRightFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(right_hwnd, gfx::Size(21, 66)));
 }
 
+TEST_F(ScreenWinTestTwoDisplays2x, GetSystemMetricsForHwnd) {
+  HWND left_hwnd = GetLeftFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
+  HWND right_hwnd = GetRightFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays2x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(2u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 960, 600), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 960, 550), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(960, 0, 400, 300), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(960, 0, 400, 300), displays[1].work_area());
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayNearestWindowPrimaryDisplay) {
@@ skipping 337 matching lines @@
 
 TEST_F(ScreenWinTestManyDisplays1x, DIPToScreenSize) {
   gfx::Size size(42, 131);
   ASSERT_EQ(5, GetScreen()->GetNumDisplays());
   for (size_t i = 0; i < 5u; ++i) {
     SCOPED_TRACE(base::StringPrintf("i=%zu", i));
     EXPECT_EQ(size, ScreenWin::DIPToScreenSize(GetFakeHwnd(i), size));
   }
 }
 
+TEST_F(ScreenWinTestManyDisplays1x, GetSystemMetricsForHwnd) {
+  for (size_t i = 0; i < 5u; ++i) {
+    SCOPED_TRACE(base::StringPrintf("i=%zu", i));
+    EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 31));
+    EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 42));
+  }
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestManyDisplays1x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(5u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 640, 480), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 640, 380), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(640, 0, 1024, 768), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(640, 0, 1024, 768), displays[1].work_area());
   EXPECT_EQ(gfx::Rect(0, 480, 640, 300), displays[2].bounds());
   EXPECT_EQ(gfx::Rect(0, 480, 640, 300), displays[2].work_area());
   EXPECT_EQ(gfx::Rect(1664, 768, 400, 400), displays[3].bounds());
@@ skipping 396 matching lines @@
   gfx::Size dip_size(21, 66);
   gfx::Size screen_size(42, 132);
   ASSERT_EQ(5, GetScreen()->GetNumDisplays());
   for (size_t i = 0; i < 5u; ++i) {
     SCOPED_TRACE(base::StringPrintf("i=%zu", i));
     EXPECT_EQ(screen_size,
               ScreenWin::DIPToScreenSize(GetFakeHwnd(i), dip_size));
   }
 }
 
+TEST_F(ScreenWinTestManyDisplays2x, GetSystemMetricsForHwnd) {
+  for (size_t i = 0; i < 5u; ++i) {
+    SCOPED_TRACE(base::StringPrintf("i=%zu", i));
+    EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 31));
+    EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 42));
+  }
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestManyDisplays2x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(5u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 320, 240), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 320, 190), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(320, 0, 512, 384), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(320, 0, 512, 384), displays[1].work_area());
   EXPECT_EQ(gfx::Rect(0, 240, 320, 150), displays[2].bounds());
   EXPECT_EQ(gfx::Rect(0, 240, 320, 150), displays[2].work_area());
   EXPECT_EQ(gfx::Rect(832, 384, 200, 200), displays[3].bounds());
@@ skipping 259 matching lines @@
 TEST_F(ScreenWinTestTwoDisplays1x2x, DIPToScreenSize) {
   HWND left_hwnd = GetLeftFakeHwnd();
   EXPECT_EQ(gfx::Size(21, 66),
             ScreenWin::DIPToScreenSize(left_hwnd, gfx::Size(21, 66)));
 
   HWND right_hwnd = GetRightFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(right_hwnd, gfx::Size(21, 66)));
 }
 
+TEST_F(ScreenWinTestTwoDisplays1x2x, GetSystemMetricsForHwnd) {
+  HWND left_hwnd = GetLeftFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
+  HWND right_hwnd = GetRightFakeHwnd();
+  EXPECT_EQ(62, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
+  EXPECT_EQ(84, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays1x2x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(2u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1200), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1920, 1100), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(1920, 0, 400, 300), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(1920, 0, 400, 300), displays[1].work_area());
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x2x, GetNumDisplays) {
@@ skipping 236 matching lines @@
 TEST_F(ScreenWinTestTwoDisplays1_5x1x, DIPToScreenSize) {
   HWND left_hwnd = GetLeftFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 131),
             ScreenWin::DIPToScreenSize(left_hwnd, gfx::Size(28, 87)));
 
   HWND right_hwnd = GetRightFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 131),
             ScreenWin::DIPToScreenSize(right_hwnd, gfx::Size(42, 131)));
 }
 
+TEST_F(ScreenWinTestTwoDisplays1_5x1x, GetSystemMetricsForHwnd) {
+  HWND left_hwnd = GetLeftFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
+  HWND right_hwnd = GetRightFakeHwnd();
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
+  EXPECT_EQ(28, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays1_5x1x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(2u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 534, 400), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 534, 367), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(534, -80, 640, 480), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(534, -80, 640, 480), displays[1].work_area());
 }
 
 TEST_F(ScreenWinTestTwoDisplays1_5x1x, GetDisplayNearestWindowPrimaryDisplay) {
@@ skipping 232 matching lines @@
 TEST_F(ScreenWinTestTwoDisplays2x1x, DIPToScreenSize) {
   HWND left_hwnd = GetLeftFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(left_hwnd, gfx::Size(21, 66)));
 
   HWND right_hwnd = GetRightFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 131),
             ScreenWin::DIPToScreenSize(right_hwnd, gfx::Size(42, 131)));
 }
 
+TEST_F(ScreenWinTestTwoDisplays2x1x, GetSystemMetricsForHwnd) {
+  HWND left_hwnd = GetLeftFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
+  HWND right_hwnd = GetRightFakeHwnd();
+  EXPECT_EQ(16, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays2x1x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(2u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 960, 600), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 960, 550), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(960, 0, 800, 600), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(960, 0, 800, 600), displays[1].work_area());
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1x, GetNumDisplays) {
@@ skipping 237 matching lines @@
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, DIPToScreenSize) {
   HWND left_hwnd = GetLeftFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(left_hwnd, gfx::Size(21, 66)));
 
   HWND right_hwnd = GetRightFakeHwnd();
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(right_hwnd, gfx::Size(21, 66)));
 }
 
+TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetSystemMetricsForHwnd) {
+  HWND left_hwnd = GetLeftFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
+  HWND right_hwnd = GetRightFakeHwnd();
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(2u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 1600, 800), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1600, 750), displays[0].work_area());
   EXPECT_EQ(gfx::Rect(3200, 0, 1920, 1200), displays[1].bounds());
   EXPECT_EQ(gfx::Rect(3200, 0, 1920, 1200), displays[1].work_area());
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetNumDisplays) {
@@ skipping 148 matching lines @@
 TEST_F(ScreenWinUninitializedForced1x, ScreenToDIPSize) {
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(nullptr, size));
 }
 
 TEST_F(ScreenWinUninitializedForced1x, DIPToScreenSize) {
   gfx::Size size(42, 131);
   EXPECT_EQ(size, ScreenWin::DIPToScreenSize(nullptr, size));
 }
 
+TEST_F(ScreenWinUninitializedForced1x, GetSystemMetricsForHwnd) {
+  // GetSystemMetricsForHwnd falls back to the system's GetSystemMetrics, so
+  // this test is to make sure we don't crash.
+  ScreenWin::GetSystemMetricsForHwnd(nullptr, SM_CXSIZEFRAME);
+}
+
 namespace {
 
 // Forced 2x DPI for Other Tests without TestScreenWin.
 class ScreenWinUninitializedForced2x : public testing::Test {
  public:
   ScreenWinUninitializedForced2x() = default;
 
   void SetUp() override {
     testing::Test::SetUp();
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
@@ skipping 76 matching lines @@
 TEST_F(ScreenWinUninitializedForced2x, ScreenToDIPSize) {
   EXPECT_EQ(gfx::Size(21, 66),
             ScreenWin::ScreenToDIPSize(nullptr, gfx::Size(42, 131)));
 }
 
 TEST_F(ScreenWinUninitializedForced2x, DIPToScreenSize) {
   EXPECT_EQ(gfx::Size(42, 132),
             ScreenWin::DIPToScreenSize(nullptr, gfx::Size(21, 66)));
 }
 
+TEST_F(ScreenWinUninitializedForced2x, GetSystemMetricsForHwnd) {
+  // GetSystemMetricsForHwnd falls back to the system's GetSystemMetrics, so
+  // this test is to make sure we don't crash.
+  ScreenWin::GetSystemMetricsForHwnd(nullptr, SM_CXSIZEFRAME);
+}
+
 }  // namespace win
 }  // namespace display