Fix window positioning in high-DPI on Windows.

ui/views/widget/desktop_aura/desktop_root_window_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_root_window_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/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/cursor/cursor_loader_win.h"
 #include "ui/base/ime/input_method_win.h"
+#include "ui/base/win/dpi.h"
 #include "ui/base/win/shell.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/path_win.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/native_theme/native_theme_win.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/cursor_manager.h"
 #include "ui/views/corewm/focus_controller.h"
@@ skipping 80 matching lines @@
                         native_widget_delegate_);
 
   HWND parent_hwnd = NULL;
   aura::Window* parent_window = params.parent;
   if (parent_window)
     parent_hwnd = parent_window->GetRootWindow()->GetAcceleratedWidget();
 
   message_handler_->set_remove_standard_frame(params.remove_standard_frame);
 
   has_non_client_view_ = Widget::RequiresNonClientView(params.type);
-  message_handler_->Init(parent_hwnd, params.bounds);
+
+  gfx::Rect pixel_bounds = ui::win::DIPToScreenRect(params.bounds);
+  message_handler_->Init(parent_hwnd, pixel_bounds);
 
   aura::RootWindow::CreateParams rw_params(params.bounds);
   rw_params.host = this;
   root_window_ = new aura::RootWindow(rw_params);
 
   // TODO(beng): We probably need to move these two calls to some function that
   //             can change depending on the native-ness of the frame. For right
   //             now in the hack-n-slash days of win-aura, we can just
   //             unilaterally turn this on.
   root_window_->compositor()->SetHostHasTransparentBackground(true);
@@ skipping 77 matching lines @@
   return this;
 }
 
 void DesktopRootWindowHostWin::ShowWindowWithState(
     ui::WindowShowState show_state) {
   message_handler_->ShowWindowWithState(show_state);
 }
 
 void DesktopRootWindowHostWin::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
-  message_handler_->ShowMaximizedWithBounds(restored_bounds);
+  gfx::Rect pixel_bounds = ui::win::DIPToScreenRect(restored_bounds);
+  message_handler_->ShowMaximizedWithBounds(pixel_bounds);
 }
 
 bool DesktopRootWindowHostWin::IsVisible() const {
   return message_handler_->IsVisible();
 }
 
 void DesktopRootWindowHostWin::SetSize(const gfx::Size& size) {
-  message_handler_->SetSize(size);
+  gfx::Size size_in_pixels = ui::win::DIPToScreenSize(size);
+  message_handler_->SetSize(size_in_pixels);
 }
 
 void DesktopRootWindowHostWin::CenterWindow(const gfx::Size& size) {
-  message_handler_->CenterWindow(size);
+  gfx::Size size_in_pixels = ui::win::DIPToScreenSize(size);
+  message_handler_->CenterWindow(size_in_pixels);
 }
 
 void DesktopRootWindowHostWin::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   message_handler_->GetWindowPlacement(bounds, show_state);
+  *bounds = ui::win::ScreenToDIPRect(*bounds);
 }
 
 gfx::Rect DesktopRootWindowHostWin::GetWindowBoundsInScreen() const {
-  return message_handler_->GetWindowBoundsInScreen();
+  gfx::Rect pixel_bounds = message_handler_->GetWindowBoundsInScreen();
+  return ui::win::ScreenToDIPRect(pixel_bounds);
 }
 
 gfx::Rect DesktopRootWindowHostWin::GetClientAreaBoundsInScreen() const {
-  return message_handler_->GetClientAreaBoundsInScreen();
+  gfx::Rect pixel_bounds = message_handler_->GetClientAreaBoundsInScreen();
+  return ui::win::ScreenToDIPRect(pixel_bounds);
 }
 
 gfx::Rect DesktopRootWindowHostWin::GetRestoredBounds() const {
-  return message_handler_->GetRestoredBounds();
+  gfx::Rect pixel_bounds = message_handler_->GetRestoredBounds();
+  return ui::win::ScreenToDIPRect(pixel_bounds);
 }
 
 gfx::Rect DesktopRootWindowHostWin::GetWorkAreaBoundsInScreen() const {
   MONITORINFO monitor_info;
   monitor_info.cbSize = sizeof(monitor_info);
   GetMonitorInfo(MonitorFromWindow(message_handler_->hwnd(),
                                    MONITOR_DEFAULTTONEAREST),
                  &monitor_info);
-  return gfx::Rect(monitor_info.rcWork);
+  gfx::Rect pixel_bounds = gfx::Rect(monitor_info.rcWork);
+  return ui::win::ScreenToDIPRect(pixel_bounds);
 }
 
 void DesktopRootWindowHostWin::SetShape(gfx::NativeRegion native_region) {
   SkPath path;
   native_region->getBoundaryPath(&path);
   message_handler_->SetRegion(gfx::CreateHRGNFromSkPath(path));
 }
 
 void DesktopRootWindowHostWin::Activate() {
   message_handler_->Activate();
@@ skipping 127 matching lines @@
 }
 
 void DesktopRootWindowHostWin::Hide() {
   if (!pending_close_)
     message_handler_->Hide();
 }
 
 void DesktopRootWindowHostWin::ToggleFullScreen() {
 }
 
+// GetBounds and SetBounds work in pixel coordinates, whereas other get/set
+// methods work in DIP.
+
 gfx::Rect DesktopRootWindowHostWin::GetBounds() const {
   // Match the logic in HWNDMessageHandler::ClientAreaSizeChanged().
-  gfx::Rect bounds(WidgetSizeIsClientSize() ? GetClientAreaBoundsInScreen()
-                                            : GetWindowBoundsInScreen());
+  gfx::Rect bounds(WidgetSizeIsClientSize() ?
+      message_handler_->GetClientAreaBoundsInScreen() :
+      message_handler_->GetWindowBoundsInScreen());
   gfx::Rect without_expansion(bounds.x() - window_expansion_.x(),
                               bounds.y() - window_expansion_.y(),
                               bounds.width() - window_expansion_.width(),
                               bounds.height() - window_expansion_.height());
   return without_expansion;
 }
 
 void DesktopRootWindowHostWin::SetBounds(const gfx::Rect& bounds) {
   gfx::Rect expanded(bounds.x() + window_expansion_.x(),
                      bounds.y() + window_expansion_.y(),
@@ skipping 289 matching lines @@
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
 void DesktopRootWindowHostWin::HandleClientSizeChanged(
     const gfx::Size& new_size) {
   gfx::Size without_expansion(new_size.width() - window_expansion_.width(),
                               new_size.height() - window_expansion_.height());
   if (root_window_host_delegate_)
     root_window_host_delegate_->OnHostResized(new_size);
   // TODO(beng): replace with a layout manager??
-  content_window_->SetBounds(gfx::Rect(without_expansion));
-  native_widget_delegate_->OnNativeWidgetSizeChanged(new_size);
+  gfx::Size dip_size = ui::win::ScreenToDIPSize(without_expansion);
+  content_window_->SetBounds(gfx::Rect(dip_size));
+  native_widget_delegate_->OnNativeWidgetSizeChanged(dip_size);
 }
 
 void DesktopRootWindowHostWin::HandleFrameChanged() {
   // Replace the frame and layout the contents.
   GetWidget()->non_client_view()->UpdateFrame(true);
 }
 
 void DesktopRootWindowHostWin::HandleNativeFocus(HWND last_focused_window) {
   // TODO(beng): inform the native_widget_delegate_.
   InputMethod* input_method = GetInputMethod();
@@ skipping 111 matching lines @@
 DesktopRootWindowHost* DesktopRootWindowHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura,
     const gfx::Rect& initial_bounds) {
   return new DesktopRootWindowHostWin(native_widget_delegate,
                                       desktop_native_widget_aura,
                                       initial_bounds);
 }
 
 }  // namespace views