Support multi touch on Windows 8 AURA and ASH.

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 <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/threading/thread.h"
 #include "base/win/metro.h"
 #include "base/win/win_util.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/base/gestures/gesture_sequence.h"
 #include "ui/metro_viewer/metro_viewer_messages.h"
 #include "win8/metro_driver/file_picker_ash.h"
 #include "win8/metro_driver/metro_driver.h"
 #include "win8/metro_driver/winrt_utils.h"
 
 typedef winfoundtn::ITypedEventHandler<
     winapp::Core::CoreApplicationView*,
     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
 
 typedef winfoundtn::ITypedEventHandler<
@@ skipping 106 matching lines @@
 }
 
 // This class helps decoding the pointer properties of an event.
 class PointerInfoHandler {
  public:
   PointerInfoHandler() :
       x_(0),
       y_(0),
       wheel_delta_(0),
       update_kind_(winui::Input::PointerUpdateKind_Other),
-      timestamp_(0) {}
+      timestamp_(0),
+      pointer_id_(0) {}
 
   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;
-
     x_ = point.X;
     y_ = point.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;
     return S_OK;
   }
 
   bool IsType(windevs::Input::PointerDeviceType type) const {
     mswr::ComPtr<windevs::Input::IPointerDevice> pointer_device;
     CheckHR(pointer_point_->get_PointerDevice(&pointer_device));
     windevs::Input::PointerDeviceType device_type;
     CheckHR(pointer_device->get_PointerDeviceType(&device_type));
     return  (device_type == type);
   }
@@ skipping 25 matching lines @@
       case winui::Input::PointerUpdateKind_MiddleButtonReleased:
         return ui::EF_MIDDLE_MOUSE_BUTTON;
       default:
         return ui::EF_NONE;
     };
   }
 
   int x() const { return x_; }
   int y() const { return y_; }
 
+  uint32 pointer_id() const {
+    return pointer_id_;
+  }
+
   uint64 timestamp() const { return timestamp_; }
 
  private:
   int x_;
   int y_;
   int wheel_delta_;
+  uint32 pointer_id_;
   winui::Input::PointerUpdateKind update_kind_;
   mswr::ComPtr<winui::Input::IPointerPoint> pointer_point_;
   uint64 timestamp_;
 };
 
 void RunMessageLoop(winui::Core::ICoreDispatcher* dispatcher) {
   // We're entering a nested message loop, let's allow dispatching
   // tasks while we're in there.
   MessageLoop::current()->SetNestableTasksAllowed(true);
 
@@ skipping 304 matching lines @@
     return hr;
 
   if (pointer.IsMouse()) {
     ui_channel_->Send(new MetroViewerHostMsg_MouseMoved(pointer.x(),
                                                         pointer.y(),
                                                         mouse_down_flags_));
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchMoved(pointer.x(),
                                                         pointer.y(),
-                                                        pointer.timestamp()));
+                                                        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.
 HRESULT ChromeAppViewAsh::OnPointerPressed(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     mouse_down_flags_ = pointer.flags();
     ui_channel_->Send(new MetroViewerHostMsg_MouseButton(pointer.x(),
                                                          pointer.y(),
                                                          0,
                                                          ui::ET_MOUSE_PRESSED,
                                                          mouse_down_flags_));
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchDown(pointer.x(),
                                                        pointer.y(),
-                                                       pointer.timestamp()));
+                                                       pointer.timestamp(),
+                                                       pointer.pointer_id()));
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnPointerReleased(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     mouse_down_flags_ = ui::EF_NONE;
     ui_channel_->Send(new MetroViewerHostMsg_MouseButton(pointer.x(),
                                                          pointer.y(),
                                                          0,
                                                          ui::ET_MOUSE_RELEASED,
                                                          pointer.flags()));
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchUp(pointer.x(),
                                                      pointer.y(),
-                                                     pointer.timestamp()));
+                                                     pointer.timestamp(),
+                                                     pointer.pointer_id()));
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnWheel(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
@@ skipping 136 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;
 }