Use the win32 device scale factor in Chrome ASH on Windows.

win8/metro_driver/chrome_app_view_ash.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 "win8/metro_driver/stdafx.h"
 #include "win8/metro_driver/chrome_app_view_ash.h"
 
 #include <corewindow.h>
 #include <shellapi.h>
 #include <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "base/win/metro.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/gestures/gesture_sequence.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/win/dpi.h"
 #include "ui/metro_viewer/metro_viewer_messages.h"
 #include "win8/metro_driver/file_picker_ash.h"
 #include "win8/metro_driver/ime/ime_popup_monitor.h"
 #include "win8/metro_driver/ime/input_source.h"
 #include "win8/metro_driver/ime/text_service.h"
 #include "win8/metro_driver/metro_driver.h"
 #include "win8/metro_driver/winrt_utils.h"
 #include "win8/viewer/metro_viewer_constants.h"
 
 typedef winfoundtn::ITypedEventHandler<
@@ skipping 319 matching lines @@
   sei.lpParameters = parameters.c_str();
   ::ShellExecuteEx(&sei);
   return true;
 }
 
 }  // namespace
 
 // This class helps decoding the pointer properties of an event.
 class ChromeAppViewAsh::PointerInfoHandler {
  public:
-  PointerInfoHandler()
+  PointerInfoHandler(float metro_dpi_scale, float win32_dpi_scale)
       : x_(0),
         y_(0),
         wheel_delta_(0),
         update_kind_(winui::Input::PointerUpdateKind_Other),
         timestamp_(0),
         pointer_id_(0),
         mouse_down_flags_(0),
-        is_horizontal_wheel_(0) {}
+        is_horizontal_wheel_(0),
+        metro_dpi_scale_(metro_dpi_scale),
+        win32_dpi_scale_(win32_dpi_scale) {}
 
   HRESULT Init(winui::Core::IPointerEventArgs* args) {
     HRESULT hr = args->get_CurrentPoint(&pointer_point_);
     if (FAILED(hr))
       return hr;
 
     winfoundtn::Point point;
     hr = pointer_point_->get_Position(&point);
     if (FAILED(hr))
       return hr;
 
     mswr::ComPtr<winui::Input::IPointerPointProperties> properties;
     hr = pointer_point_->get_Properties(&properties);
     if (FAILED(hr))
       return hr;
 
     hr = properties->get_PointerUpdateKind(&update_kind_);
     if (FAILED(hr))
       return hr;
 
     hr = properties->get_MouseWheelDelta(&wheel_delta_);
     if (FAILED(hr))
       return hr;
 
     is_horizontal_wheel_ = 0;
     properties->get_IsHorizontalMouseWheel(&is_horizontal_wheel_);
 
-    x_ = point.X;
-    y_ = point.Y;
-
+    // The input coordinates are in DIP based on the metro scale factor.
+    // We want to convert it to DIP based on the win32 scale factor.
+    // We scale the point by the metro scale factor and then scale down
+    // via the win32 scale factor which achieves the needful.

[cpu_(ooo_6.6-7.5), 2014/05/27 21:56:27]

keep up to "scale factor."

[ananta, 2014/05/27 22:46:16]

Please elaborate. Did you indicate changing "We scale the point by the ..."
above to "We scale the point to the Win32 scale factor?"

+    gfx::Point dip_point_metro(point.X, point.Y);
+    gfx::Point scaled_point_metro =
+      gfx::ToCeiledPoint(gfx::ScalePoint(dip_point_metro, metro_dpi_scale_));
+    gfx::Point dip_point_win32 =
+        gfx::ToCeiledPoint(gfx::ScalePoint(scaled_point_metro,
+                                           1.0 / win32_dpi_scale_));
+    x_ = dip_point_win32.x();
+    y_ = dip_point_win32.y();
+    
     pointer_point_->get_Timestamp(&timestamp_);
     pointer_point_->get_PointerId(&pointer_id_);
     // Map the OS touch event id to a range allowed by the gesture recognizer.
     if (IsTouch())
       pointer_id_ %= ui::GestureSequence::kMaxGesturePoints;
 
     boolean left_button_state;
     hr = properties->get_IsLeftButtonPressed(&left_button_state);
     if (FAILED(hr))
       return hr;
@@ skipping 81 matching lines @@
   mswr::ComPtr<winui::Input::IPointerPoint> pointer_point_;
   uint64 timestamp_;
 
   // Bitmask of ui::EventFlags corresponding to the buttons that are currently
   // down.
   uint32 mouse_down_flags_;
 
   // Set to true for a horizontal wheel message.
   boolean is_horizontal_wheel_;
 
+  // The metro device scale factor as reported by the winrt interfaces.
+  float metro_dpi_scale_;
+  // The win32 dpi scale which is queried via GetDeviceCaps. Please refer to
+  // ui/gfx/win/dpi.cc for more information.
+  float win32_dpi_scale_;
+
   DISALLOW_COPY_AND_ASSIGN(PointerInfoHandler);
 };
 
 ChromeAppViewAsh::ChromeAppViewAsh()
     : mouse_down_flags_(ui::EF_NONE),
       ui_channel_(nullptr),
       core_window_hwnd_(NULL),
-      scale_(0) {
+      metro_dpi_scale_(0),
+      win32_dpi_scale_(0) {
   DVLOG(1) << __FUNCTION__;
   globals.previous_state =
       winapp::Activation::ApplicationExecutionState_NotRunning;
 }
 
 ChromeAppViewAsh::~ChromeAppViewAsh() {
   DVLOG(1) << __FUNCTION__;
 }
 
 IFACEMETHODIMP
@@ skipping 99 matching lines @@
         this, &ChromeAppViewAsh::OnEdgeGestureCompleted).Get(),
         &edgeevent_token_);
     CheckHR(hr);
   }
 
   // By initializing the direct 3D swap chain with the corewindow
   // we can now directly blit to it from the browser process.
   direct3d_helper_.Initialize(window);
   DVLOG(1) << "Initialized Direct3D.";
 
-  scale_ = GetModernUIScale();
-  DVLOG(1) << "Scale is " << scale_;
+  // On Windows 8+ the WinRT interface IDisplayProperties which we use to get
+  // device scale factor does not return the correct values in metro mode.
+  // To workaround this we retrieve the device scale factor via the win32 way
+  // and scale input coordinates accordingly to pass them in DIP to chrome.
+  // TODO(ananta). Investigate and fix.
+  metro_dpi_scale_ = GetModernUIScale();
+  win32_dpi_scale_ = gfx::GetDPIScale();
+  DVLOG(1) << "Metro Scale is " << metro_dpi_scale_;
+  DVLOG(1) << "Win32 Scale is " << win32_dpi_scale_;
   return S_OK;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Load(HSTRING entryPoint) {
   // On Win7 |entryPoint| is NULL.
   DVLOG(1) << __FUNCTION__;
   return S_OK;
 }
 
@@ skipping 24 matching lines @@
   ChromeChannelListener ui_channel_listener(&ui_loop_, this);
   IPC::ChannelProxy ui_channel(win8::kMetroViewerIPCChannelName,
                                IPC::Channel::MODE_NAMED_CLIENT,
                                &ui_channel_listener,
                                io_thread.message_loop_proxy());
   ui_channel_ = &ui_channel;
 
   // Upon receipt of the MetroViewerHostMsg_SetTargetSurface message the
   // browser will use D3D from the browser process to present to our Window.
   ui_channel_->Send(new MetroViewerHostMsg_SetTargetSurface(
-                    gfx::NativeViewId(core_window_hwnd_), scale_));
+                    gfx::NativeViewId(core_window_hwnd_), win32_dpi_scale_));
   DVLOG(1) << "ICoreWindow sent " << core_window_hwnd_;
 
   // Send an initial size message so that the Ash root window host gets sized
   // correctly.
   RECT rect = {0};
   ::GetWindowRect(core_window_hwnd_, &rect);
   ui_channel_->Send(
       new MetroViewerHostMsg_WindowSizeChanged(rect.right - rect.left,
                                                rect.bottom - rect.top));
 
@@ skipping 351 matching lines @@
   // in turn launches the chrome browser process in desktop mode via
   // ShellExecute. If we call ICoreWindow::Activate before this, then
   // Windows kills the metro chrome process when it calls ShellExecute. Seems
   // to be a bug.
   window_->Activate();
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnPointerMoved(winui::Core::ICoreWindow* sender,
                                          winui::Core::IPointerEventArgs* args) {
-  PointerInfoHandler pointer;
+  PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     GenerateMouseEventFromMoveIfNecessary(pointer);
     ui_channel_->Send(new MetroViewerHostMsg_MouseMoved(
         pointer.x(),
         pointer.y(),
         mouse_down_flags_ | GetKeyboardEventFlags()));
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchMoved(pointer.x(),
                                                         pointer.y(),
                                                         pointer.timestamp(),
                                                         pointer.pointer_id()));
   }
   return S_OK;
 }
 
 // NOTE: From experimentation, it seems like Metro only sends a PointerPressed
 // event for the first button pressed and the last button released in a sequence
 // of mouse events.
 // For example, a sequence of LEFT_DOWN, RIGHT_DOWN, LEFT_UP, RIGHT_UP results
 // only in PointerPressed(LEFT)/PointerReleased(RIGHT) events. Intermediary
 // presses and releases are tracked in OnPointMoved().
 HRESULT ChromeAppViewAsh::OnPointerPressed(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
-  PointerInfoHandler pointer;
+  PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     mouse_down_flags_ = pointer.mouse_down_flags();
     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_PRESSED,
                     mouse_down_flags_ | GetKeyboardEventFlags(),
                     pointer.changed_button(), pointer.is_horizontal_wheel());
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchDown(pointer.x(),
                                                        pointer.y(),
                                                        pointer.timestamp(),
                                                        pointer.pointer_id()));
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnPointerReleased(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
-  PointerInfoHandler pointer;
+  PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     mouse_down_flags_ = ui::EF_NONE;
     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_RELEASED,
                     static_cast<uint32>(pointer.changed_button()) |
                     GetKeyboardEventFlags(),
                     pointer.changed_button(),
                     pointer.is_horizontal_wheel());
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchUp(pointer.x(),
                                                      pointer.y(),
                                                      pointer.timestamp(),
                                                      pointer.pointer_id()));
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnWheel(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
-  PointerInfoHandler pointer;
+  PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
   DCHECK(pointer.IsMouse());
   SendMouseButton(pointer.x(), pointer.y(), pointer.wheel_delta(),
                   ui::ET_MOUSEWHEEL, ui::EF_NONE, ui::EF_NONE,
                   pointer.is_horizontal_wheel());
   return S_OK;
 }
 
@@ skipping 222 matching lines @@
   mswr::ComPtr<winapp::Core::ICoreApplicationExit> app_exit;
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   *view = mswr::Make<ChromeAppViewAsh>().Detach();
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }