Added missing pen tilt when creating PointerEvent from ME.

components/test_runner/event_sender.cc

 // Copyright 2014 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 "components/test_runner/event_sender.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 43 matching lines @@
 using blink::WebString;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using blink::WebVector;
 using blink::WebView;
 
 namespace test_runner {
 
 namespace {
 
-const int kMousePointerId = -1;
+const int kRawMousePointerId = -1;
 const char* kPointerTypeStringUnknown = "";
 const char* kPointerTypeStringMouse = "mouse";
 const char* kPointerTypeStringPen = "pen";
 const char* kPointerTypeStringTouch = "touch";
 
 // Assigns |pointerType| from the provided |args|. Returns false if there was
 // any error.
 bool getPointerType(gin::Arguments* args,
                     bool isOnlyMouseAndPenAllowed,
-                    blink::WebPointerProperties::PointerType& pointerType) {
+                    WebPointerProperties::PointerType& pointerType) {
   if (args->PeekNext().IsEmpty())
     return true;
   std::string pointer_type_string;
   if (!args->GetNext(&pointer_type_string)) {
     args->ThrowError();
     return false;
   }
   if (isOnlyMouseAndPenAllowed &&
       (pointer_type_string == kPointerTypeStringUnknown ||
        pointer_type_string == kPointerTypeStringTouch)) {
     args->ThrowError();
     return false;
   }
   if (pointer_type_string == kPointerTypeStringUnknown) {
     pointerType = WebMouseEvent::PointerType::Unknown;
   } else if (pointer_type_string == kPointerTypeStringMouse) {
     pointerType = WebMouseEvent::PointerType::Mouse;
   } else if (pointer_type_string == kPointerTypeStringPen) {
     pointerType = WebMouseEvent::PointerType::Pen;
   } else if (pointer_type_string == kPointerTypeStringTouch) {
     pointerType = WebMouseEvent::PointerType::Touch;
   } else {
     args->ThrowError();
     return false;
   }
   return true;
 }
 
-// Assigns |pointerType| and |pointerId| from the provided |args|. Returns
-// false if there was any error.
-bool getMousePenPointerTypeAndId(
+// Parses |pointerType|, |rawPointerId|, |pressure|, |tiltX| and |tiltY| from
+// the provided |args|. Returns false if there was any error, assuming the last
+// 3 of the five parsed parameters are optional.
+bool getMousePenPointerProperties(
     gin::Arguments* args,
-    blink::WebPointerProperties::PointerType& pointerType,
-    int& pointerId) {
-  pointerType = blink::WebPointerProperties::PointerType::Mouse;
-  pointerId = kMousePointerId;
+    WebPointerProperties::PointerType& pointerType,
+    int& rawPointerId,
+    float& pressure,
+    int& tiltX,
+    int& tiltY) {
+  pointerType = WebPointerProperties::PointerType::Mouse;
+  rawPointerId = kRawMousePointerId;
+  pressure = std::numeric_limits<float>::quiet_NaN();
+  tiltX = 0;
+  tiltY = 0;
+
   // Only allow pen or mouse through this API.
   if (!getPointerType(args, false, pointerType))
     return false;
   if (!args->PeekNext().IsEmpty()) {
-    if (!args->GetNext(&pointerId)) {
+    if (!args->GetNext(&rawPointerId)) {
       args->ThrowError();
       return false;
     }
-    if (pointerType != blink::WebPointerProperties::PointerType::Mouse &&
-        pointerId == kMousePointerId) {
-      args->ThrowError();
-      return false;
+
+    // Parse optional params
+    if (!args->PeekNext().IsEmpty()) {
+      if (!args->GetNext(&pressure)) {
+        args->ThrowError();
+        return false;
+      }
+      if (!args->PeekNext().IsEmpty()) {
+        if (!args->GetNext(&tiltX)) {
+          args->ThrowError();
+          return false;
+        }
+        if (!args->PeekNext().IsEmpty()) {
+          if (!args->GetNext(&tiltY)) {
+            args->ThrowError();
+            return false;
+          }
+        }
+      }
     }
-  } else if (pointerType == blink::WebPointerProperties::PointerType::Pen) {
-    pointerId = 1;  // A default value for the id of the pen.
   }
+
   return true;
 }
 
 WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) {
   switch (button_code) {
     case -1:
       return WebMouseEvent::ButtonNone;
     case 0:
       return WebMouseEvent::ButtonLeft;
     case 1:
@@ skipping 21 matching lines @@
 }
 
 const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown
     | WebMouseEvent::MiddleButtonDown | WebMouseEvent::RightButtonDown;
 
 int modifiersWithButtons(int modifiers, int buttons) {
   return (modifiers & ~kButtonsInModifiers)
       | (buttons & kButtonsInModifiers);
 }
 
-void InitMouseEvent(WebInputEvent::Type t,
-                    WebMouseEvent::Button b,
-                    int current_buttons,
-                    const WebPoint& pos,
-                    double time_stamp,
-                    int click_count,
-                    int modifiers,
-                    blink::WebPointerProperties::PointerType pointerType,
-                    int pointerId,
-                    WebMouseEvent* e) {
+void InitMouseEventGeneric(WebInputEvent::Type t,
+                           WebMouseEvent::Button b,
+                           int current_buttons,
+                           const WebPoint& pos,
+                           double time_stamp,
+                           int click_count,
+                           int modifiers,
+                           WebPointerProperties::PointerType pointerType,
+                           int pointerId,
+                           float pressure,
+                           int tiltX,
+                           int tiltY,
+                           WebMouseEvent* e) {
   e->type = t;
   e->button = b;
   e->modifiers = modifiersWithButtons(modifiers, current_buttons);
   e->x = pos.x;
   e->y = pos.y;
   e->globalX = pos.x;
   e->globalY = pos.y;
   e->pointerType = pointerType;
   e->id = pointerId;
+  e->force = pressure;
+  e->tiltX = tiltX;
+  e->tiltY = tiltY;
   e->timeStampSeconds = time_stamp;
   e->clickCount = click_count;
 }
 
+void InitMouseEvent(WebInputEvent::Type t,
+                    WebMouseEvent::Button b,
+                    int current_buttons,
+                    const WebPoint& pos,
+                    double time_stamp,
+                    int click_count,
+                    int modifiers,
+                    WebMouseEvent* e) {
+  InitMouseEventGeneric(t, b, current_buttons, pos, time_stamp, click_count,
+                        modifiers, WebPointerProperties::PointerType::Mouse, 0,
+                        0.0, 0, 0, e);
+}
+
 void InitGestureEventFromMouseWheel(WebInputEvent::Type type,
                                     double time_stamp,
                                     const WebMouseWheelEvent& wheel_event,
                                     WebGestureEvent* gesture_event) {
   gesture_event->type = type;
   gesture_event->sourceDevice = blink::WebGestureDeviceTouchpad;
   gesture_event->x = wheel_event.x;
   gesture_event->y = wheel_event.y;
   gesture_event->globalX = wheel_event.globalX;
   gesture_event->globalY = wheel_event.globalY;
@@ skipping 781 matching lines @@
   sender_->ScheduleAsynchronousKeyDown(code_str, modifiers,
                                        static_cast<KeyLocationCode>(location));
 }
 
 void EventSenderBindings::MouseDown(gin::Arguments* args) {
   if (!sender_)
     return;
 
   int button_number = 0;
   int modifiers = 0;
-  blink::WebPointerProperties::PointerType pointerType =
-      blink::WebPointerProperties::PointerType::Mouse;
-  int pointerId = 0;
   if (!args->PeekNext().IsEmpty()) {
     if (!args->GetNext(&button_number)) {
       args->ThrowError();
       return;
     }
     if (!args->PeekNext().IsEmpty()) {
       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
       args->Skip();
     }
   }
 
-  if (!getMousePenPointerTypeAndId(args, pointerType, pointerId))
+  WebPointerProperties::PointerType pointerType =
+      WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
+  float pressure = 0;
+  int tiltX = 0;
+  int tiltY = 0;
+  if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
+                                    tiltX, tiltY))
     return;
 
-  sender_->PointerDown(button_number, modifiers, pointerType, pointerId);
+  sender_->PointerDown(button_number, modifiers, pointerType, pointerId,
+                       pressure, tiltX, tiltY);
 }
 
 void EventSenderBindings::MouseUp(gin::Arguments* args) {
   if (!sender_)
     return;
 
   int button_number = 0;
   int modifiers = 0;
-  blink::WebPointerProperties::PointerType pointerType =
-      blink::WebPointerProperties::PointerType::Mouse;
-  int pointerId = 0;
   if (!args->PeekNext().IsEmpty()) {
     if (!args->GetNext(&button_number)) {
       args->ThrowError();
       return;
     }
     if (!args->PeekNext().IsEmpty()) {
       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
       args->Skip();
     }
   }
 
-  if (!getMousePenPointerTypeAndId(args, pointerType, pointerId))
+  WebPointerProperties::PointerType pointerType =
+      WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
+  float pressure = 0;
+  int tiltX = 0;
+  int tiltY = 0;
+  if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
+                                    tiltX, tiltY))
     return;
 
-  sender_->PointerUp(button_number, modifiers, pointerType, pointerId);
+  sender_->PointerUp(button_number, modifiers, pointerType, pointerId, pressure,
+                     tiltX, tiltY);
 }
 
 void EventSenderBindings::SetMouseButtonState(gin::Arguments* args) {
   if (!sender_)
     return;
 
   int button_number;
   if (!args->GetNext(&button_number)) {
     args->ThrowError();
     return;
@@ skipping 157 matching lines @@
 }
 
 EventSender::~EventSender() {}
 
 void EventSender::Reset() {
   DCHECK(current_drag_data_.isNull());
   current_drag_data_.reset();
   current_drag_effect_ = blink::WebDragOperationNone;
   current_drag_effects_allowed_ = blink::WebDragOperationNone;
   if (view() &&
-      current_pointer_state_[kMousePointerId].pressed_button_ !=
+      current_pointer_state_[kRawMousePointerId].pressed_button_ !=
           WebMouseEvent::ButtonNone)
     view()->mouseCaptureLost();
   current_pointer_state_.clear();
   is_drag_mode_ = true;
   force_layout_on_events_ = true;
 
 #if defined(OS_WIN)
   wm_key_down_ = WM_KEYDOWN;
   wm_key_up_ = WM_KEYUP;
   wm_char_ = WM_CHAR;
@@ skipping 26 matching lines @@
 }
 
 void EventSender::SetContextMenuData(const WebContextMenuData& data) {
   last_context_menu_data_.reset(new WebContextMenuData(data));
 }
 
 void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseDown,
-                 current_pointer_state_[kMousePointerId].pressed_button_,
-                 current_pointer_state_[kMousePointerId].current_buttons_,
-                 current_pointer_state_[kMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 current_pointer_state_[kMousePointerId].modifiers_,
-                 blink::WebPointerProperties::PointerType::Mouse,
-                 0,
-                 &event);
+                 current_pointer_state_[kRawMousePointerId].pressed_button_,
+                 current_pointer_state_[kRawMousePointerId].current_buttons_,
+                 current_pointer_state_[kRawMousePointerId].last_pos_,
+                 GetCurrentEventTimeSec(), click_count_,
+                 current_pointer_state_[kRawMousePointerId].modifiers_, &event);
   WebPoint client_point(event.x, event.y);
   WebPoint screen_point(event.globalX, event.globalY);
   current_drag_data_ = drag_data;
   current_drag_effects_allowed_ = mask;
   current_drag_effect_ = view()->dragTargetDragEnter(
       drag_data, client_point, screen_point, current_drag_effects_allowed_,
       modifiersWithButtons(
-          current_pointer_state_[kMousePointerId].modifiers_,
-          current_pointer_state_[kMousePointerId].current_buttons_));
+          current_pointer_state_[kRawMousePointerId].modifiers_,
+          current_pointer_state_[kRawMousePointerId].current_buttons_));
 
   // Finish processing events.
   ReplaySavedEvents();
 }
 
 void EventSender::MouseDown(int button_number, int modifiers) {
   PointerDown(button_number, modifiers,
-              blink::WebPointerProperties::PointerType::Mouse, kMousePointerId);
+              WebPointerProperties::PointerType::Mouse, kRawMousePointerId, 0.0,
+              0, 0);
 }
 
 void EventSender::MouseUp(int button_number, int modifiers) {
-  PointerUp(button_number, modifiers,
-            blink::WebPointerProperties::PointerType::Mouse, kMousePointerId);
+  PointerUp(button_number, modifiers, WebPointerProperties::PointerType::Mouse,
+            kRawMousePointerId, 0.0, 0, 0);
 }
 
-void EventSender::PointerDown(
-    int button_number,
-    int modifiers,
-    blink::WebPointerProperties::PointerType pointerType,
-    int pointerId) {
+void EventSender::PointerDown(int button_number,
+                              int modifiers,
+                              WebPointerProperties::PointerType pointerType,
+                              int pointerId,
+                              float pressure,
+                              int tiltX,
+                              int tiltY) {
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
   WebMouseEvent event;
   int click_count = 0;
   current_pointer_state_[pointerId].pressed_button_ = button_type;
   current_pointer_state_[pointerId].current_buttons_ |=
       GetWebMouseEventModifierForButton(button_type);
   current_pointer_state_[pointerId].modifiers_ = modifiers;
 
-  if (pointerType == blink::WebPointerProperties::PointerType::Mouse) {
+  if (pointerType == WebPointerProperties::PointerType::Mouse) {
     UpdateClickCountForButton(button_type);
     click_count = click_count_;
   }
-  InitMouseEvent(WebInputEvent::MouseDown,
-                 current_pointer_state_[pointerId].pressed_button_,
-                 current_pointer_state_[pointerId].current_buttons_,
-                 current_pointer_state_[pointerId].last_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count,
-                 current_pointer_state_[pointerId].modifiers_,
-                 pointerType,
-                 pointerId,
-                 &event);
+  InitMouseEventGeneric(WebInputEvent::MouseDown,
+                        current_pointer_state_[pointerId].pressed_button_,
+                        current_pointer_state_[pointerId].current_buttons_,
+                        current_pointer_state_[pointerId].last_pos_,
+                        GetCurrentEventTimeSec(), click_count,
+                        current_pointer_state_[pointerId].modifiers_,
+                        pointerType, pointerId, pressure, tiltX, tiltY, &event);
 
   HandleInputEventOnViewOrPopup(event);
 }
 
-void EventSender::PointerUp(
-    int button_number,
-    int modifiers,
-    blink::WebPointerProperties::PointerType pointerType,
-    int pointerId) {
+void EventSender::PointerUp(int button_number,
+                            int modifiers,
+                            WebPointerProperties::PointerType pointerType,
+                            int pointerId,
+                            float pressure,
+                            int tiltX,
+                            int tiltY) {
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
-  if (pointerType == blink::WebPointerProperties::PointerType::Mouse &&
+  if (pointerType == WebPointerProperties::PointerType::Mouse &&
       is_drag_mode_ && !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_MOUSE_UP;
     saved_event.button_type = button_type;
     saved_event.modifiers = modifiers;
     mouse_event_queue_.push_back(saved_event);
     ReplaySavedEvents();
   } else {
     current_pointer_state_[pointerId].current_buttons_ &=
         ~GetWebMouseEventModifierForButton(button_type);
     current_pointer_state_[pointerId].pressed_button_ =
         WebMouseEvent::ButtonNone;
 
     WebMouseEvent event;
-    InitMouseEvent(
-        WebInputEvent::MouseUp, button_type,
-        current_pointer_state_[pointerId].current_buttons_,
-        current_pointer_state_[pointerId].last_pos_, GetCurrentEventTimeSec(),
-        pointerType == blink::WebPointerProperties::PointerType::Mouse
-            ? click_count_
-            : 0,
-        modifiers, pointerType, pointerId, &event);
+    int click_count = pointerType == WebPointerProperties::PointerType::Mouse
+                          ? click_count_
+                          : 0;
+    InitMouseEventGeneric(WebInputEvent::MouseUp, button_type,
+                          current_pointer_state_[pointerId].current_buttons_,
+                          current_pointer_state_[pointerId].last_pos_,
+                          GetCurrentEventTimeSec(), click_count, modifiers,
+                          pointerType, pointerId, pressure, tiltX, tiltY,
+                          &event);
     HandleInputEventOnViewOrPopup(event);
-    if (pointerType == blink::WebPointerProperties::PointerType::Mouse)
+    if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseUp(event);
   }
 }
 
 void EventSender::SetMouseButtonState(int button_number, int modifiers) {
-  current_pointer_state_[kMousePointerId].pressed_button_ =
+  current_pointer_state_[kRawMousePointerId].pressed_button_ =
       GetButtonTypeFromButtonNumber(button_number);
-  current_pointer_state_[kMousePointerId].current_buttons_ =
+  current_pointer_state_[kRawMousePointerId].current_buttons_ =
       (modifiers == -1)
           ? GetWebMouseEventModifierForButton(
-                current_pointer_state_[kMousePointerId].pressed_button_)
+                current_pointer_state_[kRawMousePointerId].pressed_button_)
           : modifiers & kButtonsInModifiers;
 }
 
 void EventSender::KeyDown(const std::string& code_str,
                           int modifiers,
                           KeyLocationCode location) {
   // FIXME: I'm not exactly sure how we should convert the string to a key
   // event. This seems to work in the cases I tested.
   // FIXME: Should we also generate a KEY_UP?
 
@@ skipping 212 matching lines @@
   // We just simulate the same behavior here.
   std::string edit_command;
   if (GetEditCommand(event_down, &edit_command))
     delegate()->SetEditCommand(edit_command, "");
 
   HandleInputEventOnViewOrPopup(event_down);
 
   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
     WebMouseEvent event;
     InitMouseEvent(WebInputEvent::MouseDown,
-                   current_pointer_state_[kMousePointerId].pressed_button_,
-                   current_pointer_state_[kMousePointerId].current_buttons_,
-                   current_pointer_state_[kMousePointerId].last_pos_,
-                   GetCurrentEventTimeSec(),
-                   click_count_,
-                   0,
-                   blink::WebPointerProperties::PointerType::Mouse,
-                   0,
-                   &event);
+                   current_pointer_state_[kRawMousePointerId].pressed_button_,
+                   current_pointer_state_[kRawMousePointerId].current_buttons_,
+                   current_pointer_state_[kRawMousePointerId].last_pos_,
+                   GetCurrentEventTimeSec(), click_count_, 0, &event);
     FinishDragAndDrop(event, blink::WebDragOperationNone);
   }
 
   delegate()->ClearEditCommand();
 
   if (generate_char) {
     WebKeyboardEvent event_char = event_up;
     event_char.type = WebInputEvent::Char;
     // keyIdentifier is an empty string, unless the Enter key was pressed.
     // This behavior is not standard (keyIdentifier itself is not even a
@@ skipping 23 matching lines @@
   // be requested after following mouse events.
   last_context_menu_data_.reset();
 
   // Generate right mouse down and up.
   WebMouseEvent event;
   // This is a hack to work around only allowing a single pressed button since
   // we want to test the case where both the left and right mouse buttons are
   // pressed.
   // TODO(mustaq): This hack seems unused here! But do we need this hack at all
   //   after adding current_buttons_.
-  if (current_pointer_state_[kMousePointerId].pressed_button_ ==
+  if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
       WebMouseEvent::ButtonNone) {
-    current_pointer_state_[kMousePointerId].pressed_button_ =
+    current_pointer_state_[kRawMousePointerId].pressed_button_ =
         WebMouseEvent::ButtonRight;
-    current_pointer_state_[kMousePointerId].current_buttons_ |=
+    current_pointer_state_[kRawMousePointerId].current_buttons_ |=
         GetWebMouseEventModifierForButton(
-            current_pointer_state_[kMousePointerId].pressed_button_);
+            current_pointer_state_[kRawMousePointerId].pressed_button_);
   }
-  InitMouseEvent(WebInputEvent::MouseDown,
-                 WebMouseEvent::ButtonRight,
-                 current_pointer_state_[kMousePointerId].current_buttons_,
-                 current_pointer_state_[kMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 blink::WebPointerProperties::PointerType::Mouse,
-                 0,
-                 &event);
+  InitMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::ButtonRight,
+                 current_pointer_state_[kRawMousePointerId].current_buttons_,
+                 current_pointer_state_[kRawMousePointerId].last_pos_,
+                 GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 
 #if defined(OS_WIN)
-  current_pointer_state_[kMousePointerId].current_buttons_ &=
+  current_pointer_state_[kRawMousePointerId].current_buttons_ &=
       ~GetWebMouseEventModifierForButton(WebMouseEvent::ButtonRight);
-  current_pointer_state_[kMousePointerId].pressed_button_ =
+  current_pointer_state_[kRawMousePointerId].pressed_button_ =
       WebMouseEvent::ButtonNone;
 
-  InitMouseEvent(WebInputEvent::MouseUp,
-                 WebMouseEvent::ButtonRight,
-                 current_pointer_state_[kMousePointerId].current_buttons_,
-                 current_pointer_state_[kMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 blink::WebPointerProperties::PointerType::Mouse,
-                 0,
-                 &event);
+  InitMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::ButtonRight,
+                 current_pointer_state_[kRawMousePointerId].current_buttons_,
+                 current_pointer_state_[kRawMousePointerId].last_pos_,
+                 GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 #endif
 
   std::vector<std::string> menu_items =
       MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate());
   last_context_menu_data_.reset();
   return menu_items;
 }
 
 void EventSender::TextZoomIn() {
@@ skipping 206 matching lines @@
 }
 
 void EventSender::NotifyStartOfTouchScroll() {
   WebTouchEvent event;
   event.type = WebInputEvent::TouchScrollStarted;
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::LeapForward(int milliseconds) {
   if (is_drag_mode_ &&
-      current_pointer_state_[kMousePointerId].pressed_button_ ==
+      current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::ButtonLeft &&
       !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_LEAP_FORWARD;
     saved_event.milliseconds = milliseconds;
     mouse_event_queue_.push_back(saved_event);
   } else {
     DoLeapForward(milliseconds);
   }
 }
@@ skipping 16 matching lines @@
     item.storageType = WebDragData::Item::StorageTypeFilename;
     item.filenameData = delegate()->GetAbsoluteWebStringFromUTF8Path(files[i]);
     current_drag_data_.addItem(item);
     absolute_filenames[i] = item.filenameData;
   }
   current_drag_data_.setFilesystemId(
       delegate()->RegisterIsolatedFileSystem(absolute_filenames));
   current_drag_effects_allowed_ = blink::WebDragOperationCopy;
 
   // Provide a drag source.
-  view()->dragTargetDragEnter(current_drag_data_,
-                              current_pointer_state_[kMousePointerId].last_pos_,
-                              current_pointer_state_[kMousePointerId].last_pos_,
-                              current_drag_effects_allowed_, 0);
+  view()->dragTargetDragEnter(
+      current_drag_data_, current_pointer_state_[kRawMousePointerId].last_pos_,
+      current_pointer_state_[kRawMousePointerId].last_pos_,
+      current_drag_effects_allowed_, 0);
   // |is_drag_mode_| saves events and then replays them later. We don't
   // need/want that.
   is_drag_mode_ = false;
 
   // Make the rest of eventSender think a drag is in progress.
-  current_pointer_state_[kMousePointerId].pressed_button_ =
+  current_pointer_state_[kRawMousePointerId].pressed_button_ =
       WebMouseEvent::ButtonLeft;
-  current_pointer_state_[kMousePointerId].current_buttons_ |=
+  current_pointer_state_[kRawMousePointerId].current_buttons_ |=
       GetWebMouseEventModifierForButton(
-          current_pointer_state_[kMousePointerId].pressed_button_);
+          current_pointer_state_[kRawMousePointerId].pressed_button_);
 }
 
 void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
   WebTouchPoint touch_point;
   touch_point.pointerType = WebPointerProperties::PointerType::Touch;
   touch_point.state = WebTouchPoint::StatePressed;
   touch_point.position = WebFloatPoint(x, y);
   touch_point.screenPosition = touch_point.position;
 
   int highest_id = -1;
@@ skipping 79 matching lines @@
     SendGesturesForMouseWheelEvent(wheel_event);
   }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   double x;
   double y;
-  blink::WebPointerProperties::PointerType pointerType =
-      blink::WebPointerProperties::PointerType::Mouse;
-  int pointerId = 0;
   if (!args->GetNext(&x) || !args->GetNext(&y)) {
     args->ThrowError();
     return;
   }
   WebPoint mouse_pos(static_cast<int>(x), static_cast<int>(y));
 
   int modifiers = 0;
   if (!args->PeekNext().IsEmpty()) {
     modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
     args->Skip();
   }
 
-  if (!getMousePenPointerTypeAndId(args, pointerType, pointerId))
+  WebPointerProperties::PointerType pointerType =
+      WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
+  float pressure = 0;
+  int tiltX = 0;
+  int tiltY = 0;
+  if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
+                                    tiltX, tiltY))
     return;
 
-  if (pointerType == blink::WebPointerProperties::PointerType::Mouse &&
+  if (pointerType == WebPointerProperties::PointerType::Mouse &&
       is_drag_mode_ && !replaying_saved_events_ &&
-      current_pointer_state_[kMousePointerId].pressed_button_ ==
+      current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::ButtonLeft) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_MOUSE_MOVE;
     saved_event.pos = mouse_pos;
     saved_event.modifiers = modifiers;
     mouse_event_queue_.push_back(saved_event);
   } else {
     current_pointer_state_[pointerId].last_pos_ = mouse_pos;
     WebMouseEvent event;
-    InitMouseEvent(
+    int click_count = pointerType == WebPointerProperties::PointerType::Mouse
+                          ? click_count_
+                          : 0;
+    InitMouseEventGeneric(
         WebInputEvent::MouseMove,
-        current_pointer_state_[kMousePointerId].pressed_button_,
-        current_pointer_state_[kMousePointerId].current_buttons_,
-        mouse_pos,
-        GetCurrentEventTimeSec(),
-        pointerType == blink::WebPointerProperties::PointerType::Mouse
-            ? click_count_
-            : 0,
-        modifiers,
-        pointerType,
-        pointerId,
-        &event);
+        current_pointer_state_[kRawMousePointerId].pressed_button_,
+        current_pointer_state_[kRawMousePointerId].current_buttons_, mouse_pos,
+        GetCurrentEventTimeSec(), click_count, modifiers, pointerType,
+        pointerId, pressure, tiltX, tiltY, &event);
     HandleInputEventOnViewOrPopup(event);
-    if (pointerType == blink::WebPointerProperties::PointerType::Mouse)
+    if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseMove(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   WebMouseEvent event;
-  InitMouseEvent(WebInputEvent::MouseLeave,
-                 WebMouseEvent::ButtonNone,
-                 0,
-                 current_pointer_state_[kMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 0,
-                 blink::WebPointerProperties::PointerType::Mouse,
-                 0,
-                 &event);
+  InitMouseEvent(WebInputEvent::MouseLeave, WebMouseEvent::ButtonNone, 0,
+                 current_pointer_state_[kRawMousePointerId].last_pos_,
+                 GetCurrentEventTimeSec(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseDown, weak_factory_.GetWeakPtr(),
                  button_number, modifiers)));
   delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseUp, weak_factory_.GetWeakPtr(),
@@ skipping 298 matching lines @@
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   WebInputEventResult result = HandleInputEventOnViewOrPopup(event);
 
   // Long press might start a drag drop session. Complete it if so.
   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
     WebMouseEvent mouse_event;
     InitMouseEvent(WebInputEvent::MouseDown,
-                   current_pointer_state_[kMousePointerId].pressed_button_,
-                   current_pointer_state_[kMousePointerId].current_buttons_,
-                   WebPoint(x, y), GetCurrentEventTimeSec(),
-                   click_count_,
-                   current_pointer_state_[kMousePointerId].modifiers_,
-                   blink::WebPointerProperties::PointerType::Mouse,
-                   0,
+                   current_pointer_state_[kRawMousePointerId].pressed_button_,
+                   current_pointer_state_[kRawMousePointerId].current_buttons_,
+                   WebPoint(x, y), GetCurrentEventTimeSec(), click_count_,
+                   current_pointer_state_[kRawMousePointerId].modifiers_,
                    &mouse_event);
 
     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
   }
   args->Return(result != WebInputEventResult::NotHandled);
 }
 
 void EventSender::UpdateClickCountForButton(
     WebMouseEvent::Button button_type) {
   if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
        kMultipleClickTimeSec) &&
       (!OutsideMultiClickRadius(
-          current_pointer_state_[kMousePointerId].last_pos_,
+          current_pointer_state_[kRawMousePointerId].last_pos_,
           last_click_pos_)) &&
       (button_type == last_button_type_)) {
     ++click_count_;
   } else {
     click_count_ = 1;
     last_button_type_ = button_type;
   }
 }
 
 void EventSender::InitMouseWheelEvent(gin::Arguments* args,
@@ skipping 34 matching lines @@
         }
       }
     }
   }
   if (can_scroll && send_wheel_gestures_) {
     can_scroll = false;
     *send_gestures = true;
   }
 
   InitMouseEvent(WebInputEvent::MouseWheel,
-                 current_pointer_state_[kMousePointerId].pressed_button_,
-                 current_pointer_state_[kMousePointerId].current_buttons_,
-                 current_pointer_state_[kMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 modifiers,
-                 blink::WebPointerProperties::PointerType::Mouse,
-                 0,
-                 event);
+                 current_pointer_state_[kRawMousePointerId].pressed_button_,
+                 current_pointer_state_[kRawMousePointerId].current_buttons_,
+                 current_pointer_state_[kRawMousePointerId].last_pos_,
+                 GetCurrentEventTimeSec(), click_count_, modifiers, event);
   event->wheelTicksX = static_cast<float>(horizontal);
   event->wheelTicksY = static_cast<float>(vertical);
   event->deltaX = event->wheelTicksX;
   event->deltaY = event->wheelTicksY;
   event->scrollByPage = paged;
   event->hasPreciseScrollingDeltas = has_precise_scrolling_deltas;
   event->canScroll = can_scroll;
   if (scroll_type == MouseScrollType::PIXEL) {
     event->wheelTicksX /= kScrollbarPixelsPerTick;
     event->wheelTicksY /= kScrollbarPixelsPerTick;
   } else {
     event->deltaX *= kScrollbarPixelsPerTick;
     event->deltaY *= kScrollbarPixelsPerTick;
   }
 }
 
 // Radius fields radius_x and radius_y should eventually be moved to
 // WebPointerProperties.
 // TODO(e_hakkinen): Drop radius_{x,y}_pointer parameters once that happens.
 void EventSender::InitPointerProperties(gin::Arguments* args,
-                                        blink::WebPointerProperties* e,
+                                        WebPointerProperties* e,
                                         float* radius_x_pointer,
                                         float* radius_y_pointer) {
   if (!args->PeekNext().IsEmpty()) {
     double radius_x;
     if (!args->GetNext(&radius_x)) {
       args->ThrowError();
       return;
     }
 
     double radius_y = radius_x;
@@ skipping 44 matching lines @@
     view()->dragTargetDragLeave();
   }
   view()->dragSourceEndedAt(client_point, screen_point, current_drag_effect_);
   view()->dragSourceSystemDragEnded();
 
   current_drag_data_.reset();
 }
 
 void EventSender::DoDragAfterMouseUp(const WebMouseEvent& e) {
   last_click_time_sec_ = e.timeStampSeconds;
-  last_click_pos_ = current_pointer_state_[kMousePointerId].last_pos_;
+  last_click_pos_ = current_pointer_state_[kRawMousePointerId].last_pos_;
 
   // If we're in a drag operation, complete it.
   if (current_drag_data_.isNull())
     return;
 
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
   blink::WebDragOperation drag_effect = view()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_, e.modifiers);
 
   // Bail if dragover caused cancellation.
   if (current_drag_data_.isNull())
     return;
 
   FinishDragAndDrop(e, drag_effect);
 }
 
 void EventSender::DoDragAfterMouseMove(const WebMouseEvent& e) {
-  if (current_pointer_state_[kMousePointerId].pressed_button_ ==
+  if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::ButtonNone ||
       current_drag_data_.isNull()) {
     return;
   }
 
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
   current_drag_effect_ = view()->dragTargetDragOver(
       client_point, screen_point, current_drag_effects_allowed_, e.modifiers);
 }
 
 void EventSender::ReplaySavedEvents() {
   replaying_saved_events_ = true;
   while (!mouse_event_queue_.empty()) {
     SavedEvent e = mouse_event_queue_.front();
     mouse_event_queue_.pop_front();
 
     switch (e.type) {
       case SavedEvent::TYPE_MOUSE_MOVE: {
         WebMouseEvent event;
         InitMouseEvent(
             WebInputEvent::MouseMove,
-            current_pointer_state_[kMousePointerId].pressed_button_,
-            current_pointer_state_[kMousePointerId].current_buttons_,
-            e.pos,
-            GetCurrentEventTimeSec(),
-            click_count_,
-            e.modifiers,
-            blink::WebPointerProperties::PointerType::Mouse,
-            0,
-            &event);
-        current_pointer_state_[kMousePointerId].last_pos_ =
+            current_pointer_state_[kRawMousePointerId].pressed_button_,
+            current_pointer_state_[kRawMousePointerId].current_buttons_, e.pos,
+            GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
+        current_pointer_state_[kRawMousePointerId].last_pos_ =
             WebPoint(event.x, event.y);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseMove(event);
         break;
       }
       case SavedEvent::TYPE_LEAP_FORWARD:
         DoLeapForward(e.milliseconds);
         break;
       case SavedEvent::TYPE_MOUSE_UP: {
-        current_pointer_state_[kMousePointerId].current_buttons_ &=
+        current_pointer_state_[kRawMousePointerId].current_buttons_ &=
             ~GetWebMouseEventModifierForButton(e.button_type);
-        current_pointer_state_[kMousePointerId].pressed_button_ =
+        current_pointer_state_[kRawMousePointerId].pressed_button_ =
             WebMouseEvent::ButtonNone;
 
         WebMouseEvent event;
-        InitMouseEvent(WebInputEvent::MouseUp,
-                       e.button_type,
-                       current_pointer_state_[kMousePointerId].current_buttons_,
-                       current_pointer_state_[kMousePointerId].last_pos_,
-                       GetCurrentEventTimeSec(),
-                       click_count_,
-                       e.modifiers,
-                       blink::WebPointerProperties::PointerType::Mouse,
-                       0,
-                       &event);
+        InitMouseEvent(
+            WebInputEvent::MouseUp, e.button_type,
+            current_pointer_state_[kRawMousePointerId].current_buttons_,
+            current_pointer_state_[kRawMousePointerId].last_pos_,
+            GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseUp(event);
         break;
       }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
@@ skipping 77 matching lines @@
 
 const blink::WebView* EventSender::view() const {
   return web_test_proxy_base_->web_view();
 }
 
 blink::WebView* EventSender::view() {
   return web_test_proxy_base_->web_view();
 }
 
 }  // namespace test_runner