Create ScreenWin::GetSystemMetricsInDIP and Correctly Deprecate display::win::GetSystemMetricsInDIP

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 319 matching lines @@
 }
 
 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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay1x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
 }
 
 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());
 }
@@ skipping 142 matching lines @@
 }
 
 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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(25, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(34, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay1_25x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.25, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(1u, displays.size());
   EXPECT_EQ(gfx::Rect(0, 0, 1536, 960), displays[0].bounds());
   EXPECT_EQ(gfx::Rect(0, 0, 1536, 880), displays[0].work_area());
 }
@@ skipping 131 matching lines @@
 }
 
 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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(28, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay1_5x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.5, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
 }
 
 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());
 }
@@ skipping 131 matching lines @@
 }
 
 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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestSingleDisplay2x, GetScaleFactorForHWND) {
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
 }
 
 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());
 }
@@ skipping 195 matching lines @@
   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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays1x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
 }
 
 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());
@@ skipping 244 matching lines @@
   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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays2x, GetScaleFactorForHWND) {
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
 }
 
 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());
@@ skipping 352 matching lines @@
 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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestManyDisplays1x, GetScaleFactorForHWND) {
   for (size_t i = 0; i < 5u; ++i) {
     SCOPED_TRACE(base::StringPrintf("i=%zu", i));
     EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd(i)));
   }
 }
 
 TEST_F(ScreenWinTestManyDisplays1x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(5u, displays.size());
@@ skipping 413 matching lines @@
 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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestManyDisplays2x, GetScaleFactorForHWND) {
   for (size_t i = 0; i < 5u; ++i) {
     SCOPED_TRACE(base::StringPrintf("i=%zu", i));
     EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd(i)));
   }
 }
 
 TEST_F(ScreenWinTestManyDisplays2x, GetDisplays) {
   std::vector<Display> displays = GetScreen()->GetAllDisplays();
   ASSERT_EQ(5u, displays.size());
@@ skipping 277 matching lines @@
   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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays1x2x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
 }
 
 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());
@@ skipping 252 matching lines @@
   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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(28, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays1_5x1x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.5, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
 }
 
 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());
@@ skipping 248 matching lines @@
   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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays2x1x, GetScaleFactorForHWND) {
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
 }
 
 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());
@@ skipping 253 matching lines @@
   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, GetSystemMetricsInDIP) {
+  EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
+  EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
+}
+
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetScaleFactorForHWND) {
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
 }
 
 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());
@@ skipping 159 matching lines @@
   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);
 }
 
+TEST_F(ScreenWinUninitializedForced1x, GetSystemMetricsInDIP) {
+  // GetSystemMetricsInDIP falls back to the system's GetSystemMetrics, so this
+  // test is to make sure we don't crash.
+  ScreenWin::GetSystemMetricsInDIP(SM_CXSIZEFRAME);
+}
+
 TEST_F(ScreenWinUninitializedForced1x, GetScaleFactorForHWND) {
   EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(nullptr));
 }
 
 namespace {
 
 // Forced 2x DPI for Other Tests without TestScreenWin.
 class ScreenWinUninitializedForced2x : public testing::Test {
  public:
   ScreenWinUninitializedForced2x() = default;
@@ skipping 86 matching lines @@
   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);
 }
 
+TEST_F(ScreenWinUninitializedForced2x, GetSystemMetricsInDIP) {
+  // GetSystemMetricsForHwnd falls back to the system's GetSystemMetrics, so
+  // this test is to make sure we don't crash.
+  ScreenWin::GetSystemMetricsInDIP(SM_CXSIZEFRAME);
+}
+
 TEST_F(ScreenWinUninitializedForced2x, GetScaleFactorForHWND) {
   EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(nullptr));
 }
 
 }  // namespace win
 }  // namespace display