Only Update the Scale Factor if the Scale Factor Actually Changed

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, 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());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetNumDisplays) {
   EXPECT_EQ(1, GetScreen()->GetNumDisplays());
 }
@@ skipping 138 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, 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());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayNearestWindow) {
   Screen* screen = GetScreen();
   gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
@@ skipping 127 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, 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());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayNearestWindow) {
   Screen* screen = GetScreen();
   gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
@@ skipping 127 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, 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());
 }
 
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayNearestWindow) {
   Screen* screen = GetScreen();
   gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
@@ skipping 191 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, 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());
   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 239 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, 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());
   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 347 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, 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());
   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 406 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, 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());
   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 270 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, 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());
   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 247 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, 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());
   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 243 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, 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());
   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 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(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, 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());
   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 154 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, 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;
 
   void SetUp() override {
     testing::Test::SetUp();
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
@@ skipping 82 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, GetScaleFactorForHWND) {
+  EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(nullptr));
+}
+
 }  // namespace win
 }  // namespace display