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

ui/views/widget/desktop_aura/desktop_window_tree_host_win.cc

 // Copyright (c) 2012 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/views/widget/desktop_aura/desktop_window_tree_host_win.h"
 
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/cursor/cursor_loader_win.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/win/shell.h"
 #include "ui/compositor/compositor_constants.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_win.h"
+#include "ui/gfx/screen_win.h"
 #include "ui/gfx/win/dpi.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/native_theme/native_theme_win.h"
 #include "ui/views/corewm/tooltip_win.h"
 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_win.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget_delegate.h"
@@ skipping 99 matching lines @@
                         native_widget_delegate_);
 
   HWND parent_hwnd = NULL;
   if (params.parent && params.parent->GetHost())
     parent_hwnd = params.parent->GetHost()->GetAcceleratedWidget();
 
   message_handler_->set_remove_standard_frame(params.remove_standard_frame);
 
   has_non_client_view_ = Widget::RequiresNonClientView(params.type);
 
-  gfx::Rect pixel_bounds = gfx::win::DIPToScreenRect(params.bounds);
+  // We don't have an HWND yet, so scale relative to the nearest screen.
+  gfx::Rect pixel_bounds = gfx::ScreenWin::DIPToScreenRect(nullptr,
+                                                           params.bounds);
   message_handler_->Init(parent_hwnd, pixel_bounds);
   if (params.force_software_compositing) {
     ::SetProp(GetAcceleratedWidget(),
               kForceSoftwareCompositor,
               reinterpret_cast<HANDLE>(true));
   }
   CreateCompositor();
   OnAcceleratedWidgetAvailable();
 }
 
@@ skipping 57 matching lines @@
     ui::WindowShowState show_state) {
   if (compositor())
     compositor()->SetVisible(true);
   message_handler_->ShowWindowWithState(show_state);
 }
 
 void DesktopWindowTreeHostWin::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   if (compositor())
     compositor()->SetVisible(true);
-  gfx::Rect pixel_bounds = gfx::win::DIPToScreenRect(restored_bounds);
+  gfx::Rect pixel_bounds = gfx::ScreenWin::DIPToScreenRect(GetHWND(),
+                                                           restored_bounds);
   message_handler_->ShowMaximizedWithBounds(pixel_bounds);
 }
 
 bool DesktopWindowTreeHostWin::IsVisible() const {
   return message_handler_->IsVisible();
 }
 
 void DesktopWindowTreeHostWin::SetSize(const gfx::Size& size) {
-  gfx::Size size_in_pixels = gfx::win::DIPToScreenSize(size);
+  gfx::Size size_in_pixels = gfx::ScreenWin::DIPToScreenSize(GetHWND(), size);
   gfx::Size expanded = GetExpandedWindowSize(
       message_handler_->window_ex_style(), size_in_pixels);
   window_enlargement_ =
       gfx::Vector2d(expanded.width() - size_in_pixels.width(),
                     expanded.height() - size_in_pixels.height());
   message_handler_->SetSize(expanded);
 }
 
 void DesktopWindowTreeHostWin::StackAbove(aura::Window* window) {
   HWND hwnd = HWNDForNativeView(window);
   if (hwnd)
     message_handler_->StackAbove(hwnd);
 }
 
 void DesktopWindowTreeHostWin::StackAtTop() {
   message_handler_->StackAtTop();
 }
 
 void DesktopWindowTreeHostWin::CenterWindow(const gfx::Size& size) {
-  gfx::Size size_in_pixels = gfx::win::DIPToScreenSize(size);
+  gfx::Size size_in_pixels = gfx::ScreenWin::DIPToScreenSize(GetHWND(), size);
   gfx::Size expanded_size;
   expanded_size = GetExpandedWindowSize(message_handler_->window_ex_style(),
                                         size_in_pixels);
   window_enlargement_ =
       gfx::Vector2d(expanded_size.width() - size_in_pixels.width(),
                     expanded_size.height() - size_in_pixels.height());
   message_handler_->CenterWindow(expanded_size);
 }
 
 void DesktopWindowTreeHostWin::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   message_handler_->GetWindowPlacement(bounds, show_state);
   InsetBottomRight(bounds, window_enlargement_);
-  *bounds = gfx::win::ScreenToDIPRect(*bounds);
+  *bounds = gfx::ScreenWin::ScreenToDIPRect(GetHWND(), *bounds);
 }
 
 gfx::Rect DesktopWindowTreeHostWin::GetWindowBoundsInScreen() const {
   gfx::Rect pixel_bounds = message_handler_->GetWindowBoundsInScreen();
   InsetBottomRight(&pixel_bounds, window_enlargement_);
-  return gfx::win::ScreenToDIPRect(pixel_bounds);
+  return gfx::ScreenWin::ScreenToDIPRect(GetHWND(), pixel_bounds);
 }
 
 gfx::Rect DesktopWindowTreeHostWin::GetClientAreaBoundsInScreen() const {
   gfx::Rect pixel_bounds = message_handler_->GetClientAreaBoundsInScreen();
   InsetBottomRight(&pixel_bounds, window_enlargement_);
-  return gfx::win::ScreenToDIPRect(pixel_bounds);
+  return gfx::ScreenWin::ScreenToDIPRect(GetHWND(), pixel_bounds);
 }
 
 gfx::Rect DesktopWindowTreeHostWin::GetRestoredBounds() const {
   gfx::Rect pixel_bounds = message_handler_->GetRestoredBounds();
   InsetBottomRight(&pixel_bounds, window_enlargement_);
-  return gfx::win::ScreenToDIPRect(pixel_bounds);
+  return gfx::ScreenWin::ScreenToDIPRect(GetHWND(), pixel_bounds);
 }
 
 gfx::Rect DesktopWindowTreeHostWin::GetWorkAreaBoundsInScreen() const {
   MONITORINFO monitor_info;
   monitor_info.cbSize = sizeof(monitor_info);
   GetMonitorInfo(MonitorFromWindow(message_handler_->hwnd(),
                                    MONITOR_DEFAULTTONEAREST),
                  &monitor_info);
   gfx::Rect pixel_bounds = gfx::Rect(monitor_info.rcWork);
-  return gfx::win::ScreenToDIPRect(pixel_bounds);
+  return gfx::ScreenWin::ScreenToDIPRect(GetHWND(), pixel_bounds);
 }
 
 void DesktopWindowTreeHostWin::SetShape(SkRegion* native_region) {
   if (native_region) {
     // TODO(wez): This would be a lot simpler if we were passed an SkPath.
     // See crbug.com/410593.
     SkRegion* shape = native_region;
     SkRegion device_region;
     if (gfx::GetDPIScale() > 1.0) {
       shape = &device_region;
@@ skipping 337 matching lines @@
 int DesktopWindowTreeHostWin::GetInitialShowState() const {
   return CanActivate() ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE;
 }
 
 bool DesktopWindowTreeHostWin::WillProcessWorkAreaChange() const {
   return GetWidget()->widget_delegate()->WillProcessWorkAreaChange();
 }
 
 int DesktopWindowTreeHostWin::GetNonClientComponent(
     const gfx::Point& point) const {
-  gfx::Point dip_position = gfx::win::ScreenToDIPPoint(point);
+  gfx::Point dip_position = gfx::ScreenWin::ClientToDIPPoint(GetHWND(), point);
   return native_widget_delegate_->GetNonClientComponent(dip_position);
 }
 
 void DesktopWindowTreeHostWin::GetWindowMask(const gfx::Size& size,
                                              gfx::Path* path) {
   if (GetWidget()->non_client_view()) {
     GetWidget()->non_client_view()->GetWindowMask(size, path);
   } else if (!window_enlargement_.IsZero()) {
     gfx::Rect bounds(WidgetSizeIsClientSize()
                          ? message_handler_->GetClientAreaBoundsInScreen()
@@ skipping 10 matching lines @@
 void DesktopWindowTreeHostWin::GetMinMaxSize(gfx::Size* min_size,
                                              gfx::Size* max_size) const {
   *min_size = native_widget_delegate_->GetMinimumSize();
   *max_size = native_widget_delegate_->GetMaximumSize();
 }
 
 gfx::Size DesktopWindowTreeHostWin::GetRootViewSize() const {
   return GetWidget()->GetRootView()->size();
 }
 
+gfx::Size DesktopWindowTreeHostWin::DIPToScreenSize(
+    const gfx::Size& dip_size) const {
+  return gfx::ScreenWin::DIPToScreenSize(GetHWND(), dip_size);
+}
+
 void DesktopWindowTreeHostWin::ResetWindowControls() {
   GetWidget()->non_client_view()->ResetWindowControls();
 }
 
 gfx::NativeViewAccessible DesktopWindowTreeHostWin::GetNativeViewAccessible() {
   return GetWidget()->GetRootView()->GetNativeViewAccessible();
 }
 
 bool DesktopWindowTreeHostWin::ShouldHandleSystemCommands() const {
   return GetWidget()->widget_delegate()->ShouldHandleSystemCommands();
@@ skipping 268 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostWin(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views