Add 1.25x and 1.5x ScreenWin Unit Tests

ui/gfx/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/gfx/screen_win.h"
 
 #include <windows.h>
 #include <inttypes.h>
 #include <stddef.h>
 
@@ skipping 225 matching lines @@
                             1.0);
     fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
   }
 
   HWND GetFakeHwnd() {
     return fake_hwnd_;
   }
 
  private:
   HWND fake_hwnd_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1x);
 };
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetDisplays) {
   std::vector<gfx::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) {
@@ skipping 27 matching lines @@
   EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
   EXPECT_EQ(display,
             screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetPrimaryDisplay) {
   gfx::Screen* screen = GetScreen();
   EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
 }
 
+// Single Display of 1.25 Device Scale Factor.
+class ScreenWinTestSingleDisplay1_25x : public ScreenWinTest {
+ public:
+  ScreenWinTestSingleDisplay1_25x() = default;
+
+  void SetUpScreen(TestScreenWinInitializer* initializer) override {
+    gfx::SetDefaultDeviceScaleFactor(1.25);
+    // Add Monitor of Scale Factor 1.0 since gfx::GetDPIScale performs the
+    // clamping and not ScreenWin.
+    initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
+                            gfx::Rect(0, 0, 1920, 1100),
+                            L"primary",
+                            1.0);
+    fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
+  }
+
+  HWND GetFakeHwnd() {
+    return fake_hwnd_;
+  }
+
+ private:
+  HWND fake_hwnd_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1_25x);
+};
+
+TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplays) {
+  std::vector<gfx::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) {
+  gfx::Screen* screen = GetScreen();
+  gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
+  EXPECT_EQ(screen->GetAllDisplays()[0],
+            screen->GetDisplayNearestWindow(native_window));
+}
+
+TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayNearestPoint) {
+  gfx::Screen* screen = GetScreen();
+  gfx::Display display = screen->GetAllDisplays()[0];
+  EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
+  EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(250, 952)));
+  EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(1919, 1199)));
+}
+
+TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayMatching) {
+  gfx::Screen* screen = GetScreen();
+  gfx::Display display = screen->GetAllDisplays()[0];
+  EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
+  EXPECT_EQ(display,
+            screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
+}
+TEST_F(ScreenWinTestSingleDisplay1_25x, GetPrimaryDisplay) {
+  gfx::Screen* screen = GetScreen();
+  EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
+}
+
+// Single Display of 1.25 Device Scale Factor.
+class ScreenWinTestSingleDisplay1_5x : public ScreenWinTest {
+ public:
+  ScreenWinTestSingleDisplay1_5x() = default;
+
+  void SetUpScreen(TestScreenWinInitializer* initializer) override {
+    gfx::SetDefaultDeviceScaleFactor(1.5);
+    initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
+                            gfx::Rect(0, 0, 1920, 1100),
+                            L"primary",
+                            1.5);
+    fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
+  }
+
+  HWND GetFakeHwnd() {
+    return fake_hwnd_;
+  }
+
+ private:
+  HWND fake_hwnd_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1_5x);
+};
+
+TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplays) {
+  std::vector<gfx::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) {
+  gfx::Screen* screen = GetScreen();
+  gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
+  EXPECT_EQ(screen->GetAllDisplays()[0],
+            screen->GetDisplayNearestWindow(native_window));
+}
+
+TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayNearestPoint) {
+  gfx::Screen* screen = GetScreen();
+  gfx::Display display = screen->GetAllDisplays()[0];
+  EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
+  EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(250, 524)));
+  EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(1279, 733)));
+}
+
+TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayMatching) {
+  gfx::Screen* screen = GetScreen();
+  gfx::Display display = screen->GetAllDisplays()[0];
+  EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
+  EXPECT_EQ(display,
+            screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
+}
+TEST_F(ScreenWinTestSingleDisplay1_5x, GetPrimaryDisplay) {
+  gfx::Screen* screen = GetScreen();
+  EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
+}
+
+
 // Single Display of 2.0 Device Scale Factor.
 class ScreenWinTestSingleDisplay2x : public ScreenWinTest {
  public:
   ScreenWinTestSingleDisplay2x() = default;
 
   void SetUpScreen(TestScreenWinInitializer* initializer) override {
     gfx::SetDefaultDeviceScaleFactor(2.0);
     initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
                             gfx::Rect(0, 0, 1920, 1100),
                             L"primary",
@@ skipping 11 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay2x);
 };
 
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplays) {
   std::vector<gfx::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) {
+  gfx::Screen* screen = GetScreen();
+  gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
+  EXPECT_EQ(screen->GetAllDisplays()[0],
+            screen->GetDisplayNearestWindow(native_window));
+}
+
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayNearestPoint) {
   gfx::Screen* screen = GetScreen();
   gfx::Display display = screen->GetAllDisplays()[0];
   EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
   EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(125, 476)));
   EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(959, 599)));
 }
 
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayMatching) {
   gfx::Screen* screen = GetScreen();
@@ skipping 310 matching lines @@
             screen->GetDisplayMatching(gfx::Rect(10139, 2299, 100, 100)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetPrimaryDisplay) {
   gfx::Screen* screen = GetScreen();
   gfx::Display primary = screen->GetPrimaryDisplay();
   EXPECT_EQ(gfx::Point(0, 0), primary.bounds().origin());
 }
 
 }  // namespace gfx