Fix Jumplist favicons to have high resolution in HDPI Windows displays

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 326 matching lines @@
 
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(1.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 147 matching lines @@
 
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(1.25, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 136 matching lines @@
 
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(1.5, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 136 matching lines @@
 
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(2.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 209 matching lines @@
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(1.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 257 matching lines @@
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(2.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 359 matching lines @@
   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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(1.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 418 matching lines @@
   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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(2.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 288 matching lines @@
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(2.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 265 matching lines @@
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(1.5, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 261 matching lines @@
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(2.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 266 matching lines @@
 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, GetLargestDeviceScaleFactor) {
+  EXPECT_EQ(2.0, ScreenWin::GetLargestDeviceScaleFactor());
+}
+
 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 278 matching lines @@
   // 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