Add place holder to move gfx::Display/Screen 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/display.h"
+#include "ui/display/screen.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"
 
 namespace display {
 namespace win {
 
 namespace {
 
 MONITORINFOEX CreateMonitorInfo(gfx::Rect monitor,
                                 gfx::Rect work,
                                 std::wstring device_name) {
@@ skipping 86 matching lines @@
   HWND GetRootWindow(HWND hwnd) const override {
     return hwnd;
   }
 
   std::vector<MONITORINFOEX> monitor_infos_;
   std::unordered_map<HWND, gfx::Rect> hwnd_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreenWin);
 };
 
-gfx::Screen* GetScreen() {
-  return gfx::Screen::GetScreen();
+Screen* GetScreen() {
+  return Screen::GetScreen();
 }
 
 // Allows tests to specify the screen and associated state.
 class TestScreenWinInitializer {
  public:
   virtual void AddMonitor(const gfx::Rect& pixel_bounds,
                           const gfx::Rect& pixel_work,
                           const wchar_t* device_name,
                           float device_scale_factor) = 0;
 
   virtual HWND CreateFakeHwnd(const gfx::Rect& bounds) = 0;
 };
 
 class TestScreenWinManager : public TestScreenWinInitializer {
  public:
   TestScreenWinManager() = default;
 
-  ~TestScreenWinManager() {
-    gfx::Screen::SetScreenInstance(nullptr);
-  }
+  ~TestScreenWinManager() { Screen::SetScreenInstance(nullptr); }
 
   void AddMonitor(const gfx::Rect& pixel_bounds,
                   const gfx::Rect& pixel_work,
                   const wchar_t* device_name,
                   float device_scale_factor) override {
     MONITORINFOEX monitor_info = CreateMonitorInfo(pixel_bounds,
                                                    pixel_work,
                                                    device_name);
     monitor_infos_.push_back(monitor_info);
-    display_infos_.push_back(DisplayInfo(monitor_info,
-                                         device_scale_factor,
-                                         gfx::Display::ROTATE_0));
+    display_infos_.push_back(DisplayInfo(monitor_info, device_scale_factor,
+                                         Display::ROTATE_0));
   }
 
   HWND CreateFakeHwnd(const gfx::Rect& bounds) override {
     EXPECT_EQ(screen_win_, nullptr);
     hwnd_map_.insert(std::pair<HWND, gfx::Rect>(++hwndLast_, bounds));
     return hwndLast_;
   }
 
   void InitializeScreenWin() {
     ASSERT_EQ(screen_win_, nullptr);
     screen_win_.reset(new TestScreenWin(display_infos_,
                                         monitor_infos_,
                                         hwnd_map_));
-    gfx::Screen::SetScreenInstance(screen_win_.get());
+    Screen::SetScreenInstance(screen_win_.get());
   }
 
   ScreenWin* GetScreenWin() {
     return screen_win_.get();
   }
 
  private:
   HWND hwndLast_ = nullptr;
   std::unique_ptr<ScreenWin> screen_win_;
   std::vector<MONITORINFOEX> monitor_infos_;
   std::vector<DisplayInfo> display_infos_;
   std::unordered_map<HWND, gfx::Rect> hwnd_map_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreenWinManager);
 };
 
 class ScreenWinTest : public testing::Test {
  protected:
   ScreenWinTest() = default;
 
   void SetUp() override {
     testing::Test::SetUp();
-    display::win::SetDefaultDeviceScaleFactor(1.0);
+    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();
-    display::win::SetDefaultDeviceScaleFactor(1.0);
+    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 20 matching lines @@
     return fake_hwnd_;
   }
 
  private:
   HWND fake_hwnd_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1x);
 };
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetDisplays) {
-  std::vector<gfx::Display> displays = GetScreen()->GetAllDisplays();
+  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());
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayNearestWindowPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
+  Screen* screen = GetScreen();
   EXPECT_EQ(screen->GetPrimaryDisplay(),
             screen->GetDisplayNearestWindow(nullptr));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayNearestWindow) {
-  gfx::Screen* screen = GetScreen();
+  Screen* screen = GetScreen();
   gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
   EXPECT_EQ(screen->GetAllDisplays()[0],
             screen->GetDisplayNearestWindow(native_window));
 }
 
 TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayNearestPoint) {
-  gfx::Screen* screen = GetScreen();
-  gfx::Display display = screen->GetAllDisplays()[0];
+  Screen* screen = GetScreen();
+  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(ScreenWinTestSingleDisplay1x, GetDisplayMatching) {
-  gfx::Screen* screen = GetScreen();
-  gfx::Display display = screen->GetAllDisplays()[0];
+  Screen* screen = GetScreen();
+  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(ScreenWinTestSingleDisplay1x, GetPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
+  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 {
-    display::win::SetDefaultDeviceScaleFactor(1.25);
+    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_;
   }
 
  private:
   HWND fake_hwnd_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1_25x);
 };
 
 TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplays) {
-  std::vector<gfx::Display> displays = GetScreen()->GetAllDisplays();
+  std::vector<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();
+  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];
+  Screen* screen = GetScreen();
+  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];
+  Screen* screen = GetScreen();
+  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();
+  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 {
-    display::win::SetDefaultDeviceScaleFactor(1.5);
+    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();
+  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) {
-  gfx::Screen* screen = GetScreen();
+  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];
+  Screen* screen = GetScreen();
+  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];
+  Screen* screen = GetScreen();
+  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();
+  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 {
-    display::win::SetDefaultDeviceScaleFactor(2.0);
+    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_;
   }
 
  private:
   HWND fake_hwnd_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay2x);
 };
 
 TEST_F(ScreenWinTestSingleDisplay2x, GetDisplays) {
-  std::vector<gfx::Display> displays = GetScreen()->GetAllDisplays();
+  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) {
-  gfx::Screen* screen = GetScreen();
+  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];
+  Screen* screen = GetScreen();
+  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();
-  gfx::Display display = screen->GetAllDisplays()[0];
+  Screen* screen = GetScreen();
+  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)));
 }
 
 // Two Displays of 1.0 Device Scale Factor.
 class ScreenWinTestTwoDisplays1x : public ScreenWinTest {
  public:
   ScreenWinTestTwoDisplays1x() = default;
 
@@ skipping 20 matching lines @@
   }
 
  private:
   HWND fake_hwnd_left_ = nullptr;
   HWND fake_hwnd_right_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestTwoDisplays1x);
 };
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetDisplays) {
-  std::vector<gfx::Display> displays = GetScreen()->GetAllDisplays();
+  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) {
   EXPECT_EQ(2, GetScreen()->GetNumDisplays());
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayNearestWindowPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
+  Screen* screen = GetScreen();
   EXPECT_EQ(screen->GetPrimaryDisplay(),
             screen->GetDisplayNearestWindow(nullptr));
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayNearestWindow) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   gfx::NativeWindow left_window = GetNativeWindowFromHWND(GetLeftFakeHwnd());
   EXPECT_EQ(left_display, screen->GetDisplayNearestWindow(left_window));
 
   gfx::NativeWindow right_window = GetNativeWindowFromHWND(GetRightFakeHwnd());
   EXPECT_EQ(right_display, screen->GetDisplayNearestWindow(right_window));
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayNearestPoint) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
   EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(250, 952)));
   EXPECT_EQ(left_display,
             screen->GetDisplayNearestPoint(gfx::Point(1919, 1199)));
 
   EXPECT_EQ(right_display, screen->GetDisplayNearestPoint(gfx::Point(1920, 0)));
   EXPECT_EQ(right_display,
             screen->GetDisplayNearestPoint(gfx::Point(2000, 400)));
   EXPECT_EQ(right_display,
             screen->GetDisplayNearestPoint(gfx::Point(2719, 599)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayMatching) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   EXPECT_EQ(left_display,
             screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
   EXPECT_EQ(left_display,
             screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
 
   EXPECT_EQ(right_display,
             screen->GetDisplayMatching(gfx::Rect(1920, 0, 100, 100)));
   EXPECT_EQ(right_display,
             screen->GetDisplayMatching(gfx::Rect(2619, 499, 100, 100)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays1x, GetPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
-  gfx::Display primary = screen->GetPrimaryDisplay();
+  Screen* screen = GetScreen();
+  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 {
-    display::win::SetDefaultDeviceScaleFactor(2.0);
+    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_ =
         initializer->CreateFakeHwnd(gfx::Rect(1920, 0, 800, 600));
   }
 
   HWND GetLeftFakeHwnd() {
     return fake_hwnd_left_;
   }
 
   HWND GetRightFakeHwnd() {
     return fake_hwnd_right_;
   }
 
  private:
   HWND fake_hwnd_left_ = nullptr;
   HWND fake_hwnd_right_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestTwoDisplays2x);
 };
 
 TEST_F(ScreenWinTestTwoDisplays2x, GetDisplays) {
-  std::vector<gfx::Display> displays = GetScreen()->GetAllDisplays();
+  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) {
-  gfx::Screen* screen = GetScreen();
+  Screen* screen = GetScreen();
   EXPECT_EQ(screen->GetPrimaryDisplay(),
             screen->GetDisplayNearestWindow(nullptr));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayNearestWindow) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   gfx::NativeWindow left_window = GetNativeWindowFromHWND(GetLeftFakeHwnd());
   EXPECT_EQ(left_display, screen->GetDisplayNearestWindow(left_window));
 
   gfx::NativeWindow right_window = GetNativeWindowFromHWND(GetRightFakeHwnd());
   EXPECT_EQ(right_display, screen->GetDisplayNearestWindow(right_window));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayNearestPoint) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
   EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(125, 476)));
   EXPECT_EQ(left_display,
             screen->GetDisplayNearestPoint(gfx::Point(959, 599)));
 
   EXPECT_EQ(right_display, screen->GetDisplayNearestPoint(gfx::Point(960, 0)));
   EXPECT_EQ(right_display,
             screen->GetDisplayNearestPoint(gfx::Point(1000, 200)));
   EXPECT_EQ(right_display,
             screen->GetDisplayNearestPoint(gfx::Point(1359, 299)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayMatching) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   EXPECT_EQ(left_display,
             screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
   EXPECT_EQ(left_display,
             screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
 
   EXPECT_EQ(right_display,
             screen->GetDisplayMatching(gfx::Rect(1920, 0, 100, 100)));
   EXPECT_EQ(right_display,
             screen->GetDisplayMatching(gfx::Rect(2619, 499, 100, 100)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x, GetPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
-  gfx::Display primary = screen->GetPrimaryDisplay();
+  Screen* screen = GetScreen();
+  Display primary = screen->GetPrimaryDisplay();
   EXPECT_EQ(gfx::Point(0, 0), primary.bounds().origin());
 }
 
 // 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 {
-    display::win::SetDefaultDeviceScaleFactor(2.0);
+    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_ =
         initializer->CreateFakeHwnd(gfx::Rect(6400, 0, 3840, 2400));
   }
 
   HWND GetLeftFakeHwnd() {
     return fake_hwnd_left_;
   }
 
   HWND GetRightFakeHwnd() {
     return fake_hwnd_right_;
   }
 
  private:
   HWND fake_hwnd_left_ = nullptr;
   HWND fake_hwnd_right_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTestTwoDisplays2x1xVirtualized);
 };
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetDisplays) {
-  std::vector<gfx::Display> displays = GetScreen()->GetAllDisplays();
+  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) {
   EXPECT_EQ(2, GetScreen()->GetNumDisplays());
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized,
        GetDisplayNearestWindowPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
+  Screen* screen = GetScreen();
   EXPECT_EQ(screen->GetPrimaryDisplay(),
             screen->GetDisplayNearestWindow(nullptr));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetDisplayNearestWindow) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   gfx::NativeWindow left_window = GetNativeWindowFromHWND(GetLeftFakeHwnd());
   EXPECT_EQ(left_display, screen->GetDisplayNearestWindow(left_window));
 
   gfx::NativeWindow right_window = GetNativeWindowFromHWND(GetRightFakeHwnd());
   EXPECT_EQ(right_display, screen->GetDisplayNearestWindow(right_window));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetDisplayNearestPoint) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
   EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(125, 476)));
   EXPECT_EQ(left_display,
             screen->GetDisplayNearestPoint(gfx::Point(1599, 799)));
 
   EXPECT_EQ(right_display, screen->GetDisplayNearestPoint(gfx::Point(3200, 0)));
   EXPECT_EQ(right_display,
             screen->GetDisplayNearestPoint(gfx::Point(4000, 400)));
   EXPECT_EQ(right_display,
             screen->GetDisplayNearestPoint(gfx::Point(5119, 1199)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetDisplayMatching) {
-  gfx::Screen* screen = GetScreen();
-  const gfx::Display left_display = screen->GetAllDisplays()[0];
-  const gfx::Display right_display = screen->GetAllDisplays()[1];
+  Screen* screen = GetScreen();
+  const Display left_display = screen->GetAllDisplays()[0];
+  const Display right_display = screen->GetAllDisplays()[1];
 
   EXPECT_EQ(left_display,
             screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
   EXPECT_EQ(left_display,
             screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
 
   EXPECT_EQ(right_display,
             screen->GetDisplayMatching(gfx::Rect(6400, 0, 100, 100)));
   EXPECT_EQ(right_display,
             screen->GetDisplayMatching(gfx::Rect(10139, 2299, 100, 100)));
 }
 
 TEST_F(ScreenWinTestTwoDisplays2x1xVirtualized, GetPrimaryDisplay) {
-  gfx::Screen* screen = GetScreen();
-  gfx::Display primary = screen->GetPrimaryDisplay();
+  Screen* screen = GetScreen();
+  Display primary = screen->GetPrimaryDisplay();
   EXPECT_EQ(gfx::Point(0, 0), primary.bounds().origin());
 }
 
 }  // namespace
 
 }  // namespace win
 }  // namespace display