Introduce WM_POINTER to Handle pointer events with pen type

ui/views/win/hwnd_message_handler.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/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <oleacc.h>
 #include <shellapi.h>
 #include <tchar.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/debug/alias.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/windows_version.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/internal_constants.h"
 #include "ui/base/win/lock_state.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/base/win/shell.h"
 #include "ui/base/win/touch_input.h"
 #include "ui/display/win/dpi.h"
 #include "ui/display/win/screen_win.h"
 #include "ui/events/event.h"
+#include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_win.h"
 #include "ui/events/win/system_event_state_lookup.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/icon_util.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_win.h"
 #include "ui/gfx/win/direct_manipulation.h"
 #include "ui/gfx/win/hwnd_util.h"
@@ skipping 295 matching lines @@
       is_first_nccalc_(true),
       menu_depth_(0),
       id_generator_(0),
       in_size_loop_(false),
       touch_down_contexts_(0),
       last_mouse_hwheel_time_(0),
       dwm_transition_desired_(false),
       sent_window_size_changing_(false),
       left_button_down_on_caption_(false),
       background_fullscreen_hack_(false),
+      is_pointer_in_range_(false),
       autohide_factory_(this),
       weak_factory_(this) {}
 
 HWNDMessageHandler::~HWNDMessageHandler() {
   delegate_ = NULL;
   // Prevent calls back into this class via WNDPROC now that we've been
   // destroyed.
   ClearUserData();
 }
 
@@ skipping 576 matching lines @@
   if (message == WM_ACTIVATE && IsTopLevelWindow(window))
     PostProcessActivateMessage(LOWORD(w_param), !!HIWORD(w_param),
                                reinterpret_cast<HWND>(l_param));
   return result;
 }
 
 LRESULT HWNDMessageHandler::HandleMouseMessage(unsigned int message,
                                                WPARAM w_param,
                                                LPARAM l_param,
                                                bool* handled) {
+  if (is_pointer_in_range_)

[ananta, 2017/03/09 00:37:33]

Does not appear to be set anywhere.

[lanwei, 2017/03/09 21:05:05]

It is not useful now, I deleted it.

+    return 0;
+
   // Don't track forwarded mouse messages. We expect the caller to track the
   // mouse.
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
   LRESULT ret = HandleMouseEventInternal(message, w_param, l_param, false);
   *handled = IsMsgHandled();
   return ret;
 }
 
 LRESULT HWNDMessageHandler::HandleKeyboardMessage(unsigned int message,
                                                   WPARAM w_param,
@@ skipping 12 matching lines @@
 LRESULT HWNDMessageHandler::HandleTouchMessage(unsigned int message,
                                                WPARAM w_param,
                                                LPARAM l_param,
                                                bool* handled) {
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
   LRESULT ret = OnTouchEvent(message, w_param, l_param);
   *handled = IsMsgHandled();
   return ret;
 }
 
+LRESULT HWNDMessageHandler::HandlePointerMessage(unsigned int message,
+                                                 WPARAM w_param,
+                                                 LPARAM l_param,
+                                                 bool* handled) {
+  base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
+  LRESULT ret = OnPointerEvent(message, w_param, l_param);
+  *handled = IsMsgHandled();
+  return ret;
+}
+
 LRESULT HWNDMessageHandler::HandleScrollMessage(unsigned int message,
                                                 WPARAM w_param,
                                                 LPARAM l_param,
                                                 bool* handled) {
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
   LRESULT ret = OnScrollMessage(message, w_param, l_param);
   *handled = IsMsgHandled();
   return ret;
 }
 
@@ skipping 648 matching lines @@
   POINTER_INPUT_TYPE pointer_type;
   static GetPointerTypeFn get_pointer_type = reinterpret_cast<GetPointerTypeFn>(
       GetProcAddress(GetModuleHandleA("user32.dll"), "GetPointerType"));
   if (get_pointer_type && get_pointer_type(pointer_id, &pointer_type) &&
       pointer_type == PT_TOUCHPAD)
     return PA_NOACTIVATE;
   SetMsgHandled(FALSE);
   return -1;
 }
 
+LRESULT HWNDMessageHandler::OnPointerEvent(UINT message,
+                                           WPARAM w_param,
+                                           LPARAM l_param) {
+  UINT32 pointer_id = GET_POINTERID_WPARAM(w_param);
+  using GetPointerTypeFn = BOOL(WINAPI*)(UINT32, POINTER_INPUT_TYPE*);
+
+  POINTER_INPUT_TYPE pointer_type;
+  static GetPointerTypeFn get_pointer_type = reinterpret_cast<GetPointerTypeFn>(
+      GetProcAddress(GetModuleHandleA("user32.dll"), "GetPointerType"));
+  if (get_pointer_type && get_pointer_type(pointer_id, &pointer_type)) {

[ananta, 2017/03/09 00:37:33]

If we are getting a WM_POINTER*** message then we can assume Windows 8+ and
avoid these null checks here?

[lanwei, 2017/03/09 21:05:05]

You are right, but the other places calling the GetProcAddress also have the
null check, I think it maybe possible that the function call will fail even on
Windows 8+, and on Windows 7, someone may send WM_POINTER messages manually. 
https://msdn.microsoft.com/en-us/library/windows/desktop/ms683212(v=vs.85).aspx

+    if (pointer_type != PT_PEN) {
+      SetMsgHandled(FALSE);
+      return 0;
+    }
+
+    using GetPointerPenInfoFn = BOOL(WINAPI*)(UINT32, POINTER_PEN_INFO*);
+    using GetPointerInfoFn = BOOL(WINAPI*)(UINT32, POINTER_INFO*);
+
+    POINTER_INFO pointer_info;
+    static GetPointerInfoFn get_pointer_info =
+        reinterpret_cast<GetPointerInfoFn>(
+            GetProcAddress(GetModuleHandleA("user32.dll"), "GetPointerInfo"));
+
+    POINTER_PEN_INFO pointer_pen_info;
+    static GetPointerPenInfoFn get_pointer_pen_info =
+        reinterpret_cast<GetPointerPenInfoFn>(GetProcAddress(
+            GetModuleHandleA("user32.dll"), "GetPointerPenInfo"));
+    if (get_pointer_pen_info &&
+        GetPointerPenInfo(pointer_id, &pointer_pen_info)) {
+      float pressure = (float)pointer_pen_info.pressure / 1024;
+      float rotation = pointer_pen_info.rotation;
+      int tiltX = pointer_pen_info.tiltX;
+      int tiltY = pointer_pen_info.tiltY;
+      gfx::Point point;
+      if (get_pointer_info && get_pointer_info(pointer_id, &pointer_info)) {
+        POINT client_point = pointer_info.ptPixelLocation;
+        ScreenToClient(hwnd(), &client_point);
+        point = gfx::Point(client_point.x, client_point.y);
+      }
+      ui::EventType event_type = ui::ET_MOUSE_MOVED;

[ananta, 2017/03/09 00:37:33]

Please add some comments here. The code below is creating a fake mouse message
from the pointer event and then setting up an associated pointer details
structure in the MouseEvent structure. 

Once we have that, does everything else automatically work? 

[lanwei, 2017/03/09 21:05:05]

Yes. Touch and mouse work as before, and we are receiving stylus information
through WM_POINTER messages.

+      int flag = 0;
+      switch (message) {
+        case WM_POINTERDOWN:
+          event_type = ui::ET_MOUSE_PRESSED;
+          flag = ui::EF_LEFT_MOUSE_BUTTON;
+          break;
+        case WM_POINTERUP:
+          event_type = ui::ET_MOUSE_RELEASED;
+          flag = ui::EF_LEFT_MOUSE_BUTTON;
+          break;
+        case WM_POINTERUPDATE:
+          event_type = ui::ET_MOUSE_MOVED;
+          break;
+        case WM_POINTERLEAVE:
+          event_type = ui::ET_MOUSE_EXITED;
+          break;
+        default:
+          break;
+      }
+      ui::MouseEvent event(event_type, point, point, base::TimeTicks::Now(), 0,
+                           0);
+      event.set_flags(flag);
+      ui::PointerDetails pointer_details(ui::EventPointerType::POINTER_TYPE_PEN,
+                                         0.0f, 0.0f, pressure, tiltX, tiltY,
+                                         0.0f, rotation, pointer_id);
+      event.set_pointer_details(pointer_details);
+
+      // There are cases where the code handling the message destroys the
+      // window, so use the weak ptr to check if destruction occured or not.
+      base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
+      bool handled = delegate_->HandleMouseEvent(event);
+
+      if (ref.get())
+        SetMsgHandled(handled);
+    }
+  }
+  return 0;
+}
+
 void HWNDMessageHandler::OnMove(const gfx::Point& point) {
   delegate_->HandleMove();
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnMoving(UINT param, const RECT* new_bounds) {
   delegate_->HandleMove();
 }
 
 LRESULT HWNDMessageHandler::OnNCActivate(UINT message,
@@ skipping 506 matching lines @@
     if (!ref.get())
       return;
     in_size_loop_ = false;
   }
 }
 
 void HWNDMessageHandler::OnThemeChanged() {
   ui::NativeThemeWin::CloseHandles();
 }
 
-void HWNDMessageHandler::OnTimeChange() {
-  // Call NowFromSystemTime() to force base::Time to re-initialize the clock
-  // from system time. Otherwise base::Time::Now() might continue to reflect the
-  // old system clock for some amount of time. See https://crbug.com/672906#c5
-  base::Time::NowFromSystemTime();
-}
-
 LRESULT HWNDMessageHandler::OnTouchEvent(UINT message,
                                          WPARAM w_param,
                                          LPARAM l_param) {
   // Handle touch events only on Aura for now.
   int num_points = LOWORD(w_param);
   std::unique_ptr<TOUCHINPUT[]> input(new TOUCHINPUT[num_points]);
   if (ui::GetTouchInputInfoWrapper(reinterpret_cast<HTOUCHINPUT>(l_param),
                                    num_points, input.get(),
                                    sizeof(TOUCHINPUT))) {
     // input[i].dwTime doesn't necessarily relate to the system time at all,
@@ skipping 593 matching lines @@
   MONITORINFO monitor_info = {sizeof(monitor_info)};
   GetMonitorInfo(MonitorFromWindow(hwnd(), MONITOR_DEFAULTTOPRIMARY),
                  &monitor_info);
   gfx::Rect shrunk_rect(monitor_info.rcMonitor);
   shrunk_rect.set_height(shrunk_rect.height() - 1);
   background_fullscreen_hack_ = true;
   SetBoundsInternal(shrunk_rect, false);
 }
 
 }  // namespace views