Move Windows DPI Code from ui/gfx to ui/display

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>
 
 #include <cwchar>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/win/display_info.h"
+#include "ui/display/win/dpi.h"
 #include "ui/display/win/screen_win_display.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/test/display_util.h"
-#include "ui/gfx/win/dpi.h"
 
 namespace display {
 namespace win {
 
 namespace {
 
 MONITORINFOEX CreateMonitorInfo(gfx::Rect monitor,
                                 gfx::Rect work,
                                 std::wstring device_name) {
   MONITORINFOEX monitor_info;
@@ skipping 155 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestScreenWinManager);
 };
 
 class ScreenWinTest : public testing::Test {
  protected:
   ScreenWinTest() = default;
 
   void SetUp() override {
     testing::Test::SetUp();
-    gfx::SetDefaultDeviceScaleFactor(1.0);
+    display::win::SetDefaultDeviceScaleFactor(1.0);
     screen_win_initializer_.reset(new TestScreenWinManager());
     SetUpScreen(screen_win_initializer_.get());
     screen_win_initializer_->InitializeScreenWin();
   }
 
   void TearDown() override {
     screen_win_initializer_.reset();
-    gfx::SetDefaultDeviceScaleFactor(1.0);
+    display::win::SetDefaultDeviceScaleFactor(1.0);
     testing::Test::TearDown();
   }
 
   virtual void SetUpScreen(TestScreenWinInitializer* initializer) = 0;
 
   gfx::NativeWindow GetNativeWindowFromHWND(HWND hwnd) const {
     ScreenWin* screen_win = screen_win_initializer_->GetScreenWin();
     return screen_win->GetNativeWindowFromHWND(hwnd);;
   }
 
@@ skipping 70 matching lines @@
   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
+    display::win::SetDefaultDeviceScaleFactor(1.25);
+    // Add Monitor of Scale Factor 1.0 since display::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_;
@@ skipping 39 matching lines @@
   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);
+    display::win::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_;
   }
@@ skipping 38 matching lines @@
   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);
+    display::win::SetDefaultDeviceScaleFactor(2.0);
     initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
                             gfx::Rect(0, 0, 1920, 1100),
                             L"primary",
                             2.0);
     fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
   }
 
   HWND GetFakeHwnd() {
     return fake_hwnd_;
   }
@@ skipping 137 matching lines @@
   gfx::Display primary = screen->GetPrimaryDisplay();
   EXPECT_EQ(gfx::Point(0, 0), primary.bounds().origin());
 }
 
 // Two Displays of 2.0 Device Scale Factor.
 class ScreenWinTestTwoDisplays2x : public ScreenWinTest {
  public:
   ScreenWinTestTwoDisplays2x() = default;
 
   void SetUpScreen(TestScreenWinInitializer* initializer) override {
-    gfx::SetDefaultDeviceScaleFactor(2.0);
+    display::win::SetDefaultDeviceScaleFactor(2.0);
     initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
                             gfx::Rect(0, 0, 1920, 1100),
                             L"primary",
                             2.0);
     initializer->AddMonitor(gfx::Rect(1920, 0, 800, 600),
                             gfx::Rect(1920, 0, 800, 600),
                             L"secondary",
                             2.0);
     fake_hwnd_left_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
     fake_hwnd_right_ =
@@ skipping 82 matching lines @@
 }
 
 // Two Displays of 2.0 (Left) and 1.0 (Right) Device Scale Factor under
 // Windows DPI Virtualization. Note that the displays do not form a euclidean
 // space.
 class ScreenWinTestTwoDisplays2x1xVirtualized : public ScreenWinTest {
  public:
   ScreenWinTestTwoDisplays2x1xVirtualized() = default;
 
   void SetUpScreen(TestScreenWinInitializer* initializer) override {
-    gfx::SetDefaultDeviceScaleFactor(2.0);
+    display::win::SetDefaultDeviceScaleFactor(2.0);
     initializer->AddMonitor(gfx::Rect(0, 0, 3200, 1600),
                             gfx::Rect(0, 0, 3200, 1500),
                             L"primary",
                             2.0);
     initializer->AddMonitor(gfx::Rect(6400, 0, 3840, 2400),
                             gfx::Rect(6400, 0, 3840, 2400),
                             L"secondary",
                             2.0);
     fake_hwnd_left_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 3200, 1500));
     fake_hwnd_right_ =
@@ skipping 83 matching lines @@
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetPrimaryDisplay) {
   gfx::Screen* screen = GetScreen();
   gfx::Display primary = screen->GetPrimaryDisplay();
   EXPECT_EQ(gfx::Point(0, 0), primary.bounds().origin());
 }
 
 }  // namespace
 
 }  // namespace win
 }  // namespace display