ScreenWin Testability and Restructuring

ui/gfx/win/display_manager.cc

Index: ui/gfx/win/display_manager.cc
diff --git a/ui/gfx/win/display_manager.cc b/ui/gfx/win/display_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c1c34d87ff2e1b5656d8b0b10c12ac231fab6267
--- /dev/null
+++ b/ui/gfx/win/display_manager.cc
@@ -0,0 +1,191 @@
+// Copyright 2016 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/win/display_manager.h"
+
+#include <windows.h>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/lazy_instance.h"
+#include "base/memory/scoped_ptr.h"
+#include "ui/gfx/win/display_info.h"
+#include "ui/gfx/win/display_manager_observer.h"
+#include "ui/gfx/win/dpi.h"
+#include "ui/gfx/win/screen_win_display.h"
+#include "ui/gfx/win/singleton_hwnd_observer.h"
+
+namespace {
+
+// Use Leaky since gfx::ScreenWin is leaked at exit, and LazyInstance instead of
+// Singleton allows for a substitution for testing.
+base::LazyInstance<scoped_ptr<gfx::win::DisplayManager>>::Leaky
+    g_display_manager = LAZY_INSTANCE_INITIALIZER;
+
+MONITORINFOEX MonitorInfoFromHMONITOR(HMONITOR monitor) {
+  MONITORINFOEX monitor_info;
+  ::ZeroMemory(&monitor_info, sizeof(monitor_info));
+  monitor_info.cbSize = sizeof(monitor_info);
+  ::GetMonitorInfo(monitor, &monitor_info);
+  return monitor_info;
+}
+
+BOOL CALLBACK EnumMonitorCallback(HMONITOR monitor,
+                                  HDC hdc,
+                                  LPRECT rect,
+                                  LPARAM data) {
+  std::vector<gfx::win::DisplayInfo>* display_infos =
+      reinterpret_cast<std::vector<gfx::win::DisplayInfo>*>(data);
+  DCHECK(display_infos);
+  display_infos->push_back(
+      gfx::win::DisplayInfo(MonitorInfoFromHMONITOR(monitor),
+                            gfx::GetDPIScale()));
+  return TRUE;
+}
+
+std::vector<gfx::win::DisplayInfo> GetDisplayInfosFromSystem() {
+  std::vector<gfx::win::DisplayInfo> display_infos;
+  EnumDisplayMonitors(NULL, NULL, EnumMonitorCallback,
+                      reinterpret_cast<LPARAM>(&display_infos));
+  DCHECK_EQ(static_cast<size_t>(::GetSystemMetrics(SM_CMONITORS)),
+            display_infos.size());
+  return display_infos;
+}
+
+std::vector<gfx::win::ScreenWinDisplay> DisplayInfosToScreenWinDisplays(
+    const std::vector<gfx::win::DisplayInfo>& display_infos) {
+  std::vector<gfx::win::ScreenWinDisplay> screen_win_displays;
+  for (const auto& display_info : display_infos)
+    screen_win_displays.push_back(gfx::win::ScreenWinDisplay(display_info));
+
+  return screen_win_displays;
+}
+
+}  // namespace
+
+namespace gfx {
+namespace win {
+
+// static
+DisplayManager* DisplayManager::GetInstance() {
+  if (!g_display_manager.Get().get()) {
+    g_display_manager.Get().reset(new DisplayManager());
+    g_display_manager.Get()->Initialize();
+  }
+  return g_display_manager.Get().get();
+}
+
+void DisplayManager::Initialize() {
+  singleton_hwnd_observer_.reset(
+      new gfx::SingletonHwndObserver(
+          base::Bind(&DisplayManager::WndProc, base::Unretained(this))));
+  UpdateFromDisplayInfos(GetDisplayInfosFromSystem());
+}
+
+void DisplayManager::AddObserver(DisplayManagerObserver* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void DisplayManager::RemoveObserver(DisplayManagerObserver* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+const std::vector<ScreenWinDisplay>& DisplayManager::GetScreenWinDisplays() {
+  return screen_win_displays_;
+}
+
+ScreenWinDisplay DisplayManager::GetScreenWinDisplayNearestHWND(HWND hwnd)
+    const {
+  return GetScreenWinDisplay(MonitorInfoFromWindow(hwnd,
+                                                   MONITOR_DEFAULTTONEAREST));
+}
+
+ScreenWinDisplay DisplayManager::GetScreenWinDisplayNearestScreenRect(
+    const Rect& screen_rect) const {
+  return GetScreenWinDisplay(MonitorInfoFromScreenRect(screen_rect));
+}
+
+ScreenWinDisplay DisplayManager::GetScreenWinDisplayNearestScreenPoint(
+    const Point& screen_point) const {
+  return GetScreenWinDisplay(MonitorInfoFromScreenPoint(screen_point));
+}
+
+ScreenWinDisplay DisplayManager::GetPrimaryScreenWinDisplay() const {
+  MONITORINFOEX monitor_info = MonitorInfoFromWindow(NULL,
+                                                     MONITOR_DEFAULTTOPRIMARY);
+  ScreenWinDisplay screen_win_display = GetScreenWinDisplay(monitor_info);
+  gfx::Display display = screen_win_display.display();
+  // The Windows primary monitor is defined to have an origin of (0, 0).
+  DCHECK_EQ(0, display.bounds().origin().x());
+  DCHECK_EQ(0, display.bounds().origin().y());
+  return screen_win_display;
+}
+
+MONITORINFOEX DisplayManager::MonitorInfoFromScreenPoint(
+    const gfx::Point& screen_point) const {
+  POINT initial_loc = { screen_point.x(), screen_point.y() };
+  return MonitorInfoFromHMONITOR(::MonitorFromPoint(initial_loc,
+                                                    MONITOR_DEFAULTTONEAREST));
+}
+
+MONITORINFOEX DisplayManager::MonitorInfoFromScreenRect(
+    const gfx::Rect& screen_rect) const {
+  RECT win_rect = screen_rect.ToRECT();
+  return MonitorInfoFromHMONITOR(::MonitorFromRect(&win_rect,
+                                                   MONITOR_DEFAULTTONEAREST));
+}
+
+MONITORINFOEX DisplayManager::MonitorInfoFromWindow(
+    HWND hwnd, DWORD default_options) const {
+  return MonitorInfoFromHMONITOR(::MonitorFromWindow(hwnd,
+                                                     default_options));

[oshima, 2016/01/30 00:10:33]

fit to single line?

[robliao, 2016/01/30 01:23:52]

Done.

+}
+
+HWND DisplayManager::GetRootWindow(HWND hwnd) const {
+  return ::GetAncestor(hwnd, GA_ROOT);
+}
+
+// static
+void DisplayManager::SetInstanceForTesting(
+    scoped_ptr<DisplayManager> display_manager) {
+  g_display_manager.Get() = std::move(display_manager);
+}
+
+DisplayManager::DisplayManager() = default;
+
+DisplayManager::~DisplayManager() = default;
+
+void DisplayManager::UpdateFromDisplayInfos(
+    const std::vector<DisplayInfo>& display_infos) {
+  screen_win_displays_ = DisplayInfosToScreenWinDisplays(display_infos);
+}
+
+ScreenWinDisplay DisplayManager::GetScreenWinDisplay(
+    const MONITORINFOEX& monitor_info) const {
+  int64_t id = DisplayInfo::HashDeviceName(monitor_info.szDevice);
+  for (const auto& screen_win_display : screen_win_displays_) {
+    if (screen_win_display.display().id() == id)
+      return screen_win_display;
+  }
+  // When the system isn't initialized, it means we're likely under a test.
+  DCHECK_EQ(screen_win_displays_.size(), 0u);
+  return ScreenWinDisplay();
+}
+
+void DisplayManager::WndProc(HWND hwnd,
+                             UINT message,
+                             WPARAM wparam,LPARAM lparam) {
+  if (message != WM_DISPLAYCHANGE)
+    return;
+
+  std::vector<ScreenWinDisplay> old_displays = screen_win_displays_;
+  UpdateFromDisplayInfos(GetDisplayInfosFromSystem());
+
+  FOR_EACH_OBSERVER(DisplayManagerObserver,
+                    observer_list_,
+                    OnDisplaysChanged(old_displays, screen_win_displays_));
+}
+
+}  // namespace win
+}  // namespace gfx