Move ScreenWin 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/gfx/screen_win.h"
+#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/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/display_info.h"
 #include "ui/gfx/win/dpi.h"
-#include "ui/gfx/win/screen_win_display.h"
 
-namespace gfx {
+namespace display {
+namespace win {
 
 namespace {
 
 MONITORINFOEX CreateMonitorInfo(gfx::Rect monitor,
                                 gfx::Rect work,
                                 std::wstring device_name) {
   MONITORINFOEX monitor_info;
   ::ZeroMemory(&monitor_info, sizeof(monitor_info));
   monitor_info.cbSize = sizeof(monitor_info);
   monitor_info.rcMonitor = monitor.ToRECT();
   monitor_info.rcWork = work.ToRECT();
   size_t device_char_count = ARRAYSIZE(monitor_info.szDevice);
   wcsncpy(monitor_info.szDevice, device_name.c_str(), device_char_count);
   monitor_info.szDevice[device_char_count-1] = L'\0';
   return monitor_info;
 }
 
-class TestScreenWin : public gfx::ScreenWin {
+class TestScreenWin : public ScreenWin {
  public:
-  TestScreenWin(const std::vector<gfx::win::DisplayInfo>& display_infos,
+  TestScreenWin(const std::vector<DisplayInfo>& display_infos,
                 const std::vector<MONITORINFOEX>& monitor_infos,
                 const std::unordered_map<HWND, gfx::Rect>& hwnd_map)
       : monitor_infos_(monitor_infos),
         hwnd_map_(hwnd_map) {
     UpdateFromDisplayInfos(display_infos);
   }
 
   ~TestScreenWin() override = default;
 
  protected:
-  // gfx::ScreenWin:
-  HWND GetHWNDFromNativeView(NativeView window) const override {
+  // display::win::ScreenWin:
+  HWND GetHWNDFromNativeView(gfx::NativeView window) const override {
     // NativeView is only used as an identifier in this tests, so interchange
     // NativeView with an HWND for convenience.
     return reinterpret_cast<HWND>(window);
   }
 
-  NativeWindow GetNativeWindowFromHWND(HWND hwnd) const override {
+  gfx::NativeWindow GetNativeWindowFromHWND(HWND hwnd) const override {
     // NativeWindow is only used as an identifier in this tests, so interchange
     // an HWND for a NativeWindow for convenience.
-    return reinterpret_cast<NativeWindow>(hwnd);
+    return reinterpret_cast<gfx::NativeWindow>(hwnd);
   }
 
  private:
   void Initialize() override {}
 
   MONITORINFOEX MonitorInfoFromScreenPoint(const gfx::Point& screen_point) const
       override {
     for (const MONITORINFOEX& monitor_info : monitor_infos_) {
       if (gfx::Rect(monitor_info.rcMonitor).Contains(screen_point))
         return monitor_info;
@@ skipping 41 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);
 };
 
-Screen* GetScreen() {
+gfx::Screen* GetScreen() {
   return gfx::Screen::GetScreen();
 }
 
-}  // namespace
-
 // 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);
   }
 
   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(gfx::win::DisplayInfo(monitor_info,
-                                                   device_scale_factor,
-                                                   gfx::Display::ROTATE_0));
+    display_infos_.push_back(DisplayInfo(monitor_info,
+                                         device_scale_factor,
+                                         gfx::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());
   }
 
   ScreenWin* GetScreenWin() {
     return screen_win_.get();
   }
 
  private:
   HWND hwndLast_ = nullptr;
   scoped_ptr<ScreenWin> screen_win_;
   std::vector<MONITORINFOEX> monitor_infos_;
-  std::vector<gfx::win::DisplayInfo> display_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();
     gfx::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);
     testing::Test::TearDown();
   }
 
   virtual void SetUpScreen(TestScreenWinInitializer* initializer) = 0;
 
-  NativeWindow GetNativeWindowFromHWND(HWND hwnd) const {
+  gfx::NativeWindow GetNativeWindowFromHWND(HWND hwnd) const {
     ScreenWin* screen_win = screen_win_initializer_->GetScreenWin();
     return screen_win->GetNativeWindowFromHWND(hwnd);;
   }
 
  private:
   scoped_ptr<TestScreenWinManager> screen_win_initializer_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenWinTest);
 };
 
@@ skipping 545 matching lines @@
   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();
   EXPECT_EQ(gfx::Point(0, 0), primary.bounds().origin());
 }
 
-}  // namespace gfx
+}  // namespace
+
+}  // namespace win
+}  // namespace display