Refactor Windows DPI Point, Rect, and Size for Multiple Monitor DPI Awareness

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..a78a3d2ed7dacd8ee1b94f0dd077c6e0f6a85bc5
--- /dev/null
+++ b/ui/gfx/win/display_manager.cc
@@ -0,0 +1,286 @@
+// 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/rect_util.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;
+
+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(monitor, gfx::GetDPIScale()));
+  return TRUE;
+}
+
+// static
+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;
+}
+
+std::vector<gfx::win::DisplayInfo> GetDisplayInfosFromSystem() {
+  std::vector<gfx::win::DisplayInfo> display_infos;
+  EnumDisplayMonitors(NULL, NULL, EnumMonitorCallback,
+                      reinterpret_cast<LPARAM>(&display_infos));
+  return display_infos;
+}
+
+// static
+std::vector<gfx::win::DisplayInfo>::const_iterator FindTouchingDisplayInfo(
+    const gfx::win::ScreenWinDisplay& screen_win_display,
+    const std::vector<gfx::win::DisplayInfo>& display_infos) {
+  auto end = display_infos.end();
+  for (auto display_info = display_infos.begin();
+       display_info != end;
+       display_info++) {
+    gfx::win::RectEdge edge =
+        gfx::win::RectTouch(screen_win_display.physical_bounds(),
+                            display_info->screen_rect());
+    if (edge != gfx::win::RectEdge::NONE)
+      return display_info;
+  }
+  return end;
+}
+
+std::vector<gfx::win::ScreenWinDisplay> GetScreenWinDisplaysFromDisplayInfos(
+    const std::vector<gfx::win::DisplayInfo>& display_infos) {
+  std::vector<gfx::win::DisplayInfo> display_infos_remaining = display_infos;
+
+  // Seed the primary display to layout all the other displays.
+  std::vector<gfx::win::ScreenWinDisplay> screen_win_displays;
+  for (auto current = display_infos_remaining.begin();
+       current != display_infos_remaining.end();
+       current++) {
+    if (current->screen_rect().origin().IsOrigin()) {
+      screen_win_displays.push_back(gfx::win::ScreenWinDisplay(*current));
+      display_infos_remaining.erase(current);
+      break;
+    }
+  }
+
+  // Scale touching display_infos relative to each other.
+  size_t display_infos_at_cycle_start = 0;
+  while ((display_infos_remaining.size() > 0) &&
+         (display_infos_remaining.size() != display_infos_at_cycle_start)) {
+    display_infos_at_cycle_start = display_infos_remaining.size();
+    for (const auto& screen_win_display : screen_win_displays) {
+      auto display_info = FindTouchingDisplayInfo(screen_win_display,
+                                                  display_infos_remaining);
+      if (display_info != display_infos_remaining.end()) {
+        screen_win_displays.push_back(
+            gfx::win::ScreenWinDisplay(screen_win_display, *display_info));
+        display_infos_remaining.erase(display_info);
+        break;
+      }
+    }
+  }
+
+  // Under Windows DPI virtualization, not all display_infos touch, so scale
+  // the remaining display infos relative to the origin.
+  for (const auto& display_info : display_infos_remaining) {
+    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());
+  }
+  return g_display_manager.Get().get();
+}
+
+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::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();
+}
+
+ScreenWinDisplay DisplayManager::GetScreenWinDisplayNearestHWND(HWND hwnd)
+    const {
+  return GetScreenWinDisplay(MonitorInfoFromWindow(hwnd));
+}
+
+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::GetScreenWinDisplayNearestDIPRect(
+    const Rect& dip_rect) const {
+  ScreenWinDisplay closest_display_win;
+  int64_t closest_distance_squared = INT64_MAX;
+  for (const auto& display_win : screen_win_displays_) {
+    Display display = display_win.display();
+    gfx::Rect dip_bounds = display.bounds();
+    int64_t distance_squared =
+        SquaredDistanceBetweenRects(dip_rect, dip_bounds);
+    if (distance_squared == 0) {
+      return display_win;
+    } else if (distance_squared < closest_distance_squared) {
+      closest_distance_squared = distance_squared;
+      closest_display_win = display_win;
+    }
+  }
+  return closest_display_win;
+}
+
+ScreenWinDisplay DisplayManager::GetScreenWinDisplayNearestDIPPoint(
+    const Point& dip_point) const {
+  ScreenWinDisplay primary_display_win;
+  for (const auto& display_win : screen_win_displays_) {
+    Display display = display_win.display();
+    gfx::Rect dip_bounds = display.bounds();
+    if (dip_bounds.Contains(dip_point))
+      return display_win;
+    else if (dip_bounds.origin().IsOrigin())
+      primary_display_win = display_win;
+  }
+  return primary_display_win;
+}
+
+ScreenWinDisplay DisplayManager::GetPrimaryScreenWinDisplay() const {
+  MONITORINFOEX monitor_info =
+      MonitorInfoFromHMONITOR(MonitorFromWindow(NULL,
+                                                MONITOR_DEFAULTTOPRIMARY));
+  ScreenWinDisplay screen_win_display = GetScreenWinDisplay(monitor_info);
+  gfx::Display display = screen_win_display.display();
+  // TODO(kevers|girard): Test if these checks can be reintroduced for high-DIP
+  // once more of the app is DIP-aware.
+  if (display.device_scale_factor() == 1.0) {
+    DCHECK_EQ(GetSystemMetrics(SM_CXSCREEN), display.size().width());
+    DCHECK_EQ(GetSystemMetrics(SM_CYSCREEN), display.size().height());
+  }
+  return screen_win_display;
+}
+
+float DisplayManager::GetScaleFactorForHWND(HWND hwnd) const {
+  DCHECK(hwnd);
+  HWND rootHwnd = GetRootWindow(hwnd);
+  ScreenWinDisplay screen_win_display =
+      GetScreenWinDisplayNearestHWND(rootHwnd);
+  return screen_win_display.display().device_scale_factor();
+}
+
+float DisplayManager::GetScaleFactorForScreenPoint(const Point& screen_point)
+    const {
+  ScreenWinDisplay screen_win_display =
+      GetScreenWinDisplayNearestScreenPoint(screen_point);
+  return screen_win_display.display().device_scale_factor();
+}
+
+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) const {
+  return MonitorInfoFromHMONITOR(::MonitorFromWindow(hwnd,
+                                                     MONITOR_DEFAULTTONEAREST));
+}
+
+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() {
+  singleton_hwnd_observer_.reset(
+      new gfx::SingletonHwndObserver(
+          base::Bind(&DisplayManager::WndProc, base::Unretained(this))));
+  UpdateFromDisplayInfos(GetDisplayInfosFromSystem());
+}
+
+DisplayManager::~DisplayManager() = default;
+
+void DisplayManager::UpdateFromDisplayInfos(
+    const std::vector<DisplayInfo>& display_infos) {
+  screen_win_displays_ = GetScreenWinDisplaysFromDisplayInfos(display_infos);
+}
+
+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