Consider isPrimary and pointerType when preventing compat mouse

components/test_runner/event_sender.cc

Index: components/test_runner/event_sender.cc
diff --git a/components/test_runner/event_sender.cc b/components/test_runner/event_sender.cc
index 393572482957e5cc3f4162a6fbb5fb366717c278..47ab83beaafe8f2b6d02e63e0897b13996eaba69 100644
--- a/components/test_runner/event_sender.cc
+++ b/components/test_runner/event_sender.cc
@@ -58,6 +58,69 @@ namespace test_runner {
 
 namespace {
 
+const int kMousePointerId = -1;
+const char* kPointerTypeStringUnknown = "";
+const char* kPointerTypeStringMouse = "mouse";
+const char* kPointerTypeStringPen = "pen";
+const char* kPointerTypeStringTouch = "touch";
+
+bool getPointerType(gin::Arguments* args,
+                    blink::WebPointerProperties::PointerType &t,

[dtapuska, 2016/04/07 02:35:41]

Should be PointerType& t. Both styles are allowed in the style guide; but you
need to be consistent in the file. Since the convention in this file and most;
the * and reference is with the type followed by a space.

But really you should have a better name than t; perhaps type?

Output arguments must always be last according to the style guide to. Which
won't allow you to use the default parameter. But you can easily define a
getPointerType with two args and call the 3 arg one.

Also need a bit of docs regarding that |t| is an output parameter.

[Navid Zolghadr, 2016/04/08 17:38:44]

Done. I got rid of the default value and in that single place that needed false
I passed the parameter.

+                    bool isOnlyMouseAndPenAllowed = false) {
+  if (!args->PeekNext().IsEmpty()) {
+    std::string pointer_type_string;
+    if (!args->GetNext(&pointer_type_string)) {
+      args->ThrowError();
+      return false;
+    }
+    if (pointer_type_string == kPointerTypeStringUnknown) {
+      if (isOnlyMouseAndPenAllowed) {
+        args->ThrowError();
+        return false;
+      }
+      t = WebMouseEvent::PointerType::Unknown;
+    } else if (pointer_type_string == kPointerTypeStringMouse) {
+      t = WebMouseEvent::PointerType::Mouse;
+    } else if (pointer_type_string == kPointerTypeStringPen) {
+      t = WebMouseEvent::PointerType::Pen;
+    } else if (pointer_type_string == kPointerTypeStringTouch) {
+      if (isOnlyMouseAndPenAllowed) {
+        args->ThrowError();
+        return false;
+      }
+      t = WebMouseEvent::PointerType::Touch;
+    } else {
+      args->ThrowError();
+      return false;
+    }
+  }
+  return true;

[mustaq, 2016/04/07 19:30:02]

Nit: Please avoid three levels of nested |if|s, by using short-cut returns: must
simpler to follow and less error-prone.

[Navid Zolghadr, 2016/04/08 17:38:44]

Done.

+}
+
+bool getMousePenPointerTypeAndId(gin::Arguments* args,
+                    blink::WebPointerProperties::PointerType &t,

[dtapuska, 2016/04/07 02:35:41]

ditto; comments as above.

[Navid Zolghadr, 2016/04/08 17:38:44]

Done.

+                    int &id) {
+  t = blink::WebPointerProperties::PointerType::Mouse;
+  id = kMousePointerId;
+  // Only allow pen or mouse through this API.
+  if (!getPointerType(args, t, true))
+    return false;
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&id)) {
+      args->ThrowError();
+      return false;
+    }
+    if (t != blink::WebPointerProperties::PointerType::Mouse
+        && id == kMousePointerId) {
+      args->ThrowError();
+      return false;
+    }
+  } else if (t == blink::WebPointerProperties::PointerType::Pen) {
+    id = 1; // A default value for the id of the pen
+  }
+  return true;
+}
+
 WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) {
   switch (button_code) {
     case -1:
@@ -103,6 +166,8 @@ void InitMouseEvent(WebInputEvent::Type t,
                     double time_stamp,
                     int click_count,
                     int modifiers,
+                    blink::WebPointerProperties::PointerType pointerType,
+                    int pointerId,
                     WebMouseEvent* e) {
   e->type = t;
   e->button = b;
@@ -111,7 +176,9 @@ void InitMouseEvent(WebInputEvent::Type t,
   e->y = pos.y;
   e->globalX = pos.x;
   e->globalY = pos.y;
-  e->pointerType = blink::WebPointerProperties::PointerType::Mouse;
+  e->pointerType = pointerType;
+  if (pointerType != blink::WebPointerProperties::PointerType::Mouse)

[mustaq, 2016/04/07 19:30:02]

I think it's better to allow any ids here. This would keep the gate open to
check, e.g., what would happen if Blink gets a mouse event with id=123.

[Navid Zolghadr, 2016/04/08 17:38:44]

Sure. Then here for mouse by default we are sending -1 instead of previous 0
which I believe shouldn't break the existing tests.

+    e->id = pointerId;
   e->timeStampSeconds = time_stamp;
   e->clickCount = click_count;
 }
@@ -455,11 +522,6 @@ bool GetScrollUnits(gin::Arguments* args, WebGestureEvent::ScrollUnits* units) {
 const char* kSourceDeviceStringTouchpad = "touchpad";
 const char* kSourceDeviceStringTouchscreen = "touchscreen";
 
-const char* kPointerTypeStringUnknown = "";
-const char* kPointerTypeStringMouse = "mouse";
-const char* kPointerTypeStringPen = "pen";
-const char* kPointerTypeStringTouch = "touch";
-
 }  // namespace
 
 class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
@@ -978,12 +1040,24 @@ void EventSenderBindings::MouseDown(gin::Arguments* args) {
 
   int button_number = 0;
   int modifiers = 0;
+  blink::WebPointerProperties::PointerType pointerType =
+      blink::WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
   if (!args->PeekNext().IsEmpty()) {
-    args->GetNext(&button_number);
-    if (!args->PeekNext().IsEmpty())
+    if (!args->GetNext(&button_number)) {
+      args->ThrowError();
+      return;
+    }
+    if (!args->PeekNext().IsEmpty()) {
       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
+      args->Skip();
+    }
   }
-  sender_->MouseDown(button_number, modifiers);
+
+  if (!getMousePenPointerTypeAndId(args, pointerType, pointerId))
+    return;
+
+  sender_->MouseDown(button_number, modifiers, pointerType, pointerId);
 }
 
 void EventSenderBindings::MouseUp(gin::Arguments* args) {
@@ -992,12 +1066,24 @@ void EventSenderBindings::MouseUp(gin::Arguments* args) {
 
   int button_number = 0;
   int modifiers = 0;
+  blink::WebPointerProperties::PointerType pointerType =
+      blink::WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
   if (!args->PeekNext().IsEmpty()) {
-    args->GetNext(&button_number);
-    if (!args->PeekNext().IsEmpty())
+    if (!args->GetNext(&button_number)) {
+      args->ThrowError();
+      return;
+    }
+    if (!args->PeekNext().IsEmpty()) {
       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
+      args->Skip();
+    }
   }
-  sender_->MouseUp(button_number, modifiers);
+
+  if (!getMousePenPointerTypeAndId(args, pointerType, pointerId))
+    return;
+
+  sender_->MouseUp(button_number, modifiers, pointerType, pointerId);
 }
 
 void EventSenderBindings::SetMouseButtonState(gin::Arguments* args) {
@@ -1150,12 +1236,6 @@ void EventSenderBindings::SetWmSysDeadChar(int sys_dead_char) {
 
 // EventSender -----------------------------------------------------------------
 
-WebMouseEvent::Button EventSender::pressed_button_ = WebMouseEvent::ButtonNone;
-int EventSender::current_buttons_ = 0;
-int EventSender::modifiers_ = 0;
-
-WebPoint EventSender::last_mouse_pos_;
-
 WebMouseEvent::Button EventSender::last_button_type_ =
     WebMouseEvent::ButtonNone;
 
@@ -1201,11 +1281,10 @@ void EventSender::Reset() {
   current_drag_data_.reset();
   current_drag_effect_ = blink::WebDragOperationNone;
   current_drag_effects_allowed_ = blink::WebDragOperationNone;
-  if (view_ && pressed_button_ != WebMouseEvent::ButtonNone)
+  if (view_ && current_pointer_state_[kMousePointerId].pressed_button_
+      != WebMouseEvent::ButtonNone)
     view_->mouseCaptureLost();
-  pressed_button_ = WebMouseEvent::ButtonNone;
-  current_buttons_ = 0;
-  modifiers_ = 0;
+  current_pointer_state_.clear();
   is_drag_mode_ = true;
   force_layout_on_events_ = true;
 
@@ -1220,7 +1299,6 @@ void EventSender::Reset() {
   wm_sys_dead_char_ = WM_SYSDEADCHAR;
 #endif
 
-  last_mouse_pos_ = WebPoint(0, 0);
   last_click_time_sec_ = 0;
   last_click_pos_ = WebPoint(0, 0);
   last_button_type_ = WebMouseEvent::ButtonNone;
@@ -1258,12 +1336,14 @@ void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseDown,
-                 pressed_button_,
-                 current_buttons_,
-                 last_mouse_pos_,
+                 current_pointer_state_[kMousePointerId].pressed_button_,
+                 current_pointer_state_[kMousePointerId].current_buttons_,
+                 current_pointer_state_[kMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
-                 modifiers_,
+                 current_pointer_state_[kMousePointerId].modifiers_,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &event);
   WebPoint client_point(event.x, event.y);
   WebPoint screen_point(event.globalX, event.globalY);
@@ -1274,13 +1354,15 @@ void EventSender::DoDragDrop(const WebDragData& drag_data,
       client_point,
       screen_point,
       current_drag_effects_allowed_,
-      modifiersWithButtons(modifiers_, current_buttons_));
+      modifiersWithButtons(current_pointer_state_[kMousePointerId].modifiers_,
+          current_pointer_state_[kMousePointerId].current_buttons_));
 
   // Finish processing events.
   ReplaySavedEvents();
 }
 
-void EventSender::MouseDown(int button_number, int modifiers) {
+void EventSender::MouseDown(int button_number, int modifiers,
+    blink::WebPointerProperties::PointerType pointerType, int pointerId) {
   if (force_layout_on_events_)
     view_->updateAllLifecyclePhases();
 
@@ -1289,25 +1371,33 @@ void EventSender::MouseDown(int button_number, int modifiers) {
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
-  UpdateClickCountForButton(button_type);
-
-  pressed_button_ = button_type;
-  current_buttons_ |= GetWebMouseEventModifierForButton(pressed_button_);
-  modifiers_ = modifiers;
-
   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) {
+    UpdateClickCountForButton(button_type);
+    click_count = click_count_;
+  }
   InitMouseEvent(WebInputEvent::MouseDown,
-                 pressed_button_,
-                 current_buttons_,
-                 last_mouse_pos_,
+                 current_pointer_state_[pointerId].pressed_button_,
+                 current_pointer_state_[pointerId].current_buttons_,
+                 current_pointer_state_[pointerId].last_pos_,
                  GetCurrentEventTimeSec(),
-                 click_count_,
-                 modifiers_,
+                 click_count,
+                 current_pointer_state_[pointerId].modifiers_,
+                 pointerType,
+                 pointerId,

[dtapuska, 2016/04/07 02:35:41]

Do we need to be concerned we are passing -1 potentially in here for mouse?

[Navid Zolghadr, 2016/04/07 03:08:04]

There is a check in InitMouseEvent which ignores the pointerId when the
pointerType is mouse. So basically this -1 is only an event_sender thing and
never gets exposed to the Blink.

[mustaq, 2016/04/07 19:30:02]

I am fine with allowing unexpected values here, to make event_sender more
flexible. We need the ability to test Blink with unusual values, and making the
event sender more "intelligent" about the perfect input is a bar to this. E.g.
we allow setting the |movedBeyondSlopRegion| bit in a TouchEvent even when the
touchpoint hasn't moved much. This isolates testing the dependence on this bits
w/o being worrying about a slop-region definition.

[Navid Zolghadr, 2016/04/08 17:38:44]

I removed the check in InitMouseEvent to set any id.

                  &event);
+
   HandleInputEventOnViewOrPopup(event);
 }
 
-void EventSender::MouseUp(int button_number, int modifiers) {
+void EventSender::MouseUp(int button_number, int modifiers,
+    blink::WebPointerProperties::PointerType pointerType, int pointerId) {
   if (force_layout_on_events_)
     view_->updateAllLifecyclePhases();
 
@@ -1316,34 +1406,60 @@ void EventSender::MouseUp(int button_number, int modifiers) {
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
-  if (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();
+  if (pointerType == blink::WebPointerProperties::PointerType::Mouse) {
+    if (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_[kMousePointerId].current_buttons_ &=
+            ~GetWebMouseEventModifierForButton(button_type);
+        current_pointer_state_[kMousePointerId].pressed_button_ =
+            WebMouseEvent::ButtonNone;
+
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseUp,
+                     button_type,
+                     current_pointer_state_[kMousePointerId].current_buttons_,
+                     current_pointer_state_[kMousePointerId].last_pos_,
+                     GetCurrentEventTimeSec(),
+                     click_count_,
+                     modifiers,
+                     pointerType,
+                     0,

[dtapuska, 2016/04/07 02:35:41]

Whereas we pass 0 in here for mouseup?

This code looks very duplicated to the code below except for the 0 passed in and
the DoMouseUp(...) vs HandleInputEventOnViewOrPopup.. Could we collapse them
into the same codepath? Perhaps not; just a thought.

[Navid Zolghadr, 2016/04/07 03:08:04]

I was thinking of doing this similar to what I did for mouseDown to share the
code. The problem was that there was this if else for the flow of existing mouse
(I guess it is dragging of some sort). I could have jammed the if conditions
together and somehow use one code path for firing of the event. But I thought
that might be more confusing than just duplicating this code. Which one do you
think i s better? This one or anding those conditions altogether and also add
another if at the end for the DoMouseUp vs HandleInputEventOnViewOrPopup?

[dtapuska, 2016/04/07 03:15:24]

Personally; I'd probably look at pulling the HandleInputEventOnViewOrPopup out
of the DoMouseXX method and then have a code path that was similar for the two
but do some post processing after the dispatch to call DoMouseXX..

[mustaq, 2016/04/07 19:30:02]

I agree, the two DoMouse* methods are doing local post-processing/bookkeeping
for drag right after handleInputEvent call (and MouseDown doesn't evnet have a
DoMouseDown). Please pull the handle... call out, then rename DoMouse* to
DoDragAfterMouse*.

[Navid Zolghadr, 2016/04/08 17:38:44]

Done.

+                     &event);
+      DoMouseUp(event);
+    }
   } else {
-    current_buttons_ &= ~GetWebMouseEventModifierForButton(button_type);
-    pressed_button_ = WebMouseEvent::ButtonNone;
-
-    WebMouseEvent event;
-    InitMouseEvent(WebInputEvent::MouseUp,
-                   button_type,
-                   current_buttons_,
-                   last_mouse_pos_,
-                   GetCurrentEventTimeSec(),
-                   click_count_,
-                   modifiers,
-                   &event);
-    DoMouseUp(event);
+      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(),
+                     0,
+                     modifiers,
+                     pointerType,
+                     pointerId,
+                     &event);
+      HandleInputEventOnViewOrPopup(event);
   }
 }
 
 void EventSender::SetMouseButtonState(int button_number, int modifiers) {
-  pressed_button_ = GetButtonTypeFromButtonNumber(button_number);
-  current_buttons_ = (modifiers == -1) ?
-      GetWebMouseEventModifierForButton(pressed_button_) :
+  current_pointer_state_[kMousePointerId].pressed_button_ =
+      GetButtonTypeFromButtonNumber(button_number);
+  current_pointer_state_[kMousePointerId].current_buttons_ = (modifiers == -1) ?
+      GetWebMouseEventModifierForButton(
+          current_pointer_state_[kMousePointerId].pressed_button_) :
       modifiers & kButtonsInModifiers;
 }
 
@@ -1544,12 +1660,14 @@ void EventSender::KeyDown(const std::string& code_str,
   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
     WebMouseEvent event;
     InitMouseEvent(WebInputEvent::MouseDown,
-                   pressed_button_,
-                   current_buttons_,
-                   last_mouse_pos_,
+                   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);
     FinishDragAndDrop(event, blink::WebDragOperationNone);
   }
@@ -1594,32 +1712,41 @@ std::vector<std::string> EventSender::ContextClick() {
   // pressed.
   // TODO(mustaq): This hack seems unused here! But do we need this hack at all
   //   after adding current_buttons_.
-  if (pressed_button_ == WebMouseEvent::ButtonNone) {
-    pressed_button_ = WebMouseEvent::ButtonRight;
-    current_buttons_ |= GetWebMouseEventModifierForButton(pressed_button_);
+  if (current_pointer_state_[kMousePointerId].pressed_button_
+      == WebMouseEvent::ButtonNone) {
+    current_pointer_state_[kMousePointerId].pressed_button_ =
+        WebMouseEvent::ButtonRight;
+    current_pointer_state_[kMousePointerId].current_buttons_ |=
+        GetWebMouseEventModifierForButton(
+        current_pointer_state_[kMousePointerId].pressed_button_);
   }
   InitMouseEvent(WebInputEvent::MouseDown,
                  WebMouseEvent::ButtonRight,
-                 current_buttons_,
-                 last_mouse_pos_,
+                 current_pointer_state_[kMousePointerId].current_buttons_,
+                 current_pointer_state_[kMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 
 #if defined(OS_WIN)
-  current_buttons_ &=
+  current_pointer_state_[kMousePointerId].current_buttons_ &=
       ~GetWebMouseEventModifierForButton(WebMouseEvent::ButtonRight);
-  pressed_button_ = WebMouseEvent::ButtonNone;
+  current_pointer_state_[kMousePointerId].pressed_button_ =
+      WebMouseEvent::ButtonNone;
 
   InitMouseEvent(WebInputEvent::MouseUp,
                  WebMouseEvent::ButtonRight,
-                 current_buttons_,
-                 last_mouse_pos_,
+                 current_pointer_state_[kMousePointerId].current_buttons_,
+                 current_pointer_state_[kMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 #endif
@@ -1826,7 +1953,8 @@ void EventSender::TouchEnd() {
 }
 
 void EventSender::LeapForward(int milliseconds) {
-  if (is_drag_mode_ && pressed_button_ == WebMouseEvent::ButtonLeft &&
+  if (is_drag_mode_ && current_pointer_state_[kMousePointerId].pressed_button_
+      == WebMouseEvent::ButtonLeft &&
       !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_LEAP_FORWARD;
@@ -1863,8 +1991,8 @@ void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) {
 
   // Provide a drag source.
   view_->dragTargetDragEnter(current_drag_data_,
-                             last_mouse_pos_,
-                             last_mouse_pos_,
+                             current_pointer_state_[kMousePointerId].last_pos_,
+                             current_pointer_state_[kMousePointerId].last_pos_,
                              current_drag_effects_allowed_,
                              0);
   // |is_drag_mode_| saves events and then replays them later. We don't
@@ -1872,8 +2000,11 @@ void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) {
   is_drag_mode_ = false;
 
   // Make the rest of eventSender think a drag is in progress.
-  pressed_button_ = WebMouseEvent::ButtonLeft;
-  current_buttons_ |= GetWebMouseEventModifierForButton(pressed_button_);
+  current_pointer_state_[kMousePointerId].pressed_button_ =
+      WebMouseEvent::ButtonLeft;
+  current_pointer_state_[kMousePointerId].current_buttons_ |=
+      GetWebMouseEventModifierForButton(
+      current_pointer_state_[kMousePointerId].pressed_button_);
 }
 
 void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
@@ -1973,6 +2104,9 @@ void EventSender::MouseMoveTo(gin::Arguments* args) {
 
   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;
@@ -1980,27 +2114,52 @@ void EventSender::MouseMoveTo(gin::Arguments* args) {
   WebPoint mouse_pos(static_cast<int>(x), static_cast<int>(y));
 
   int modifiers = 0;
-  if (!args->PeekNext().IsEmpty())
+  if (!args->PeekNext().IsEmpty()) {
     modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
+    args->Skip();
+  }
 
-  if (is_drag_mode_ && pressed_button_ == WebMouseEvent::ButtonLeft &&
-      !replaying_saved_events_) {
-    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);
+  if (!getMousePenPointerTypeAndId(args, pointerType, pointerId))
+    return;
+
+  if (pointerType == blink::WebPointerProperties::PointerType::Mouse) {
+    if (is_drag_mode_ && current_pointer_state_[kMousePointerId].pressed_button_
+        == WebMouseEvent::ButtonLeft
+        && !replaying_saved_events_) {
+      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 {
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseMove,
+                     current_pointer_state_[kMousePointerId].pressed_button_,
+                     current_pointer_state_[kMousePointerId].current_buttons_,
+                     mouse_pos,
+                     GetCurrentEventTimeSec(),
+                     click_count_,
+                     modifiers,
+                     pointerType,
+                     0,

[mustaq, 2016/04/07 19:30:02]

Same as before, don't worry about pointerId, and unify the duplication.

[Navid Zolghadr, 2016/04/08 17:38:44]

Done.

+                     &event);
+      DoMouseMove(event);
+    }
   } else {
-    WebMouseEvent event;
-    InitMouseEvent(WebInputEvent::MouseMove,
-                   pressed_button_,
-                   current_buttons_,
-                   mouse_pos,
-                   GetCurrentEventTimeSec(),
-                   click_count_,
-                   modifiers,
-                   &event);
-    DoMouseMove(event);
+      current_pointer_state_[pointerId].last_pos_ = mouse_pos;
+
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseMove,
+                     current_pointer_state_[pointerId].pressed_button_,
+                     current_pointer_state_[pointerId].current_buttons_,
+                     mouse_pos,
+                     GetCurrentEventTimeSec(),
+                     0,
+                     modifiers,
+                     pointerType,
+                     pointerId,
+                     &event);
+      HandleInputEventOnViewOrPopup(event);
   }
 }
 
@@ -2012,10 +2171,12 @@ void EventSender::MouseLeave() {
   InitMouseEvent(WebInputEvent::MouseLeave,
                  WebMouseEvent::ButtonNone,
                  0,
-                 last_mouse_pos_,
+                 current_pointer_state_[kMousePointerId].last_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 }
@@ -2327,12 +2488,14 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
     WebMouseEvent mouse_event;
     InitMouseEvent(WebInputEvent::MouseDown,
-                   pressed_button_,
-                   current_buttons_,
+                   current_pointer_state_[kMousePointerId].pressed_button_,
+                   current_pointer_state_[kMousePointerId].current_buttons_,
                    WebPoint(x, y),
                    GetCurrentEventTimeSec(),
                    click_count_,
-                   modifiers_,
+                   current_pointer_state_[kMousePointerId].modifiers_,
+                   blink::WebPointerProperties::PointerType::Mouse,
+                   0,
                    &mouse_event);
 
     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
@@ -2343,9 +2506,10 @@ void EventSender::GestureEvent(WebInputEvent::Type type,
 void EventSender::UpdateClickCountForButton(
     WebMouseEvent::Button button_type) {
   if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
-       kMultipleClickTimeSec) &&
-      (!OutsideMultiClickRadius(last_mouse_pos_, last_click_pos_)) &&
-      (button_type == last_button_type_)) {
+      kMultipleClickTimeSec) &&
+      (!OutsideMultiClickRadius(
+      current_pointer_state_[kMousePointerId].last_pos_, last_click_pos_))
+      && (button_type == last_button_type_)) {
     ++click_count_;
   } else {
     click_count_ = 1;
@@ -2398,12 +2562,14 @@ void EventSender::InitMouseWheelEvent(gin::Arguments* args,
   }
 
   InitMouseEvent(WebInputEvent::MouseWheel,
-                 pressed_button_,
-                 current_buttons_,
-                 last_mouse_pos_,
+                 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);
   event->wheelTicksX = static_cast<float>(horizontal);
   event->wheelTicksY = static_cast<float>(vertical);
@@ -2466,25 +2632,8 @@ void EventSender::InitPointerProperties(gin::Arguments* args,
     e->tiltY = tiltY;
   }
 
-  if (!args->PeekNext().IsEmpty()) {
-    std::string pointer_type_string;
-    if (!args->GetNext(&pointer_type_string)) {
-      args->ThrowError();
-      return;
-    }
-    if (pointer_type_string == kPointerTypeStringUnknown) {
-      e->pointerType = WebMouseEvent::PointerType::Unknown;
-    } else if (pointer_type_string == kPointerTypeStringMouse) {
-      e->pointerType = WebMouseEvent::PointerType::Mouse;
-    } else if (pointer_type_string == kPointerTypeStringPen) {
-      e->pointerType = WebMouseEvent::PointerType::Pen;
-    } else if (pointer_type_string == kPointerTypeStringTouch) {
-      e->pointerType = WebMouseEvent::PointerType::Touch;
-    } else {
-      args->ThrowError();
-      return;
-    }
-  }
+  if (!getPointerType(args, e->pointerType))
+    return;
 }
 
 void EventSender::FinishDragAndDrop(const WebMouseEvent& e,
@@ -2509,7 +2658,7 @@ void EventSender::DoMouseUp(const WebMouseEvent& e) {
   HandleInputEventOnViewOrPopup(e);
 
   last_click_time_sec_ = e.timeStampSeconds;
-  last_click_pos_ = last_mouse_pos_;
+  last_click_pos_ = current_pointer_state_[kMousePointerId].last_pos_;
 
   // If we're in a drag operation, complete it.
   if (current_drag_data_.isNull())
@@ -2531,12 +2680,13 @@ void EventSender::DoMouseUp(const WebMouseEvent& e) {
 }
 
 void EventSender::DoMouseMove(const WebMouseEvent& e) {
-  last_mouse_pos_ = WebPoint(e.x, e.y);
+  current_pointer_state_[kMousePointerId].last_pos_ = WebPoint(e.x, e.y);
 
   HandleInputEventOnViewOrPopup(e);
 
-  if (pressed_button_ == WebMouseEvent::ButtonNone ||
-      current_drag_data_.isNull()) {
+  if (current_pointer_state_[kMousePointerId].pressed_button_
+      == WebMouseEvent::ButtonNone
+      || current_drag_data_.isNull()) {
     return;
   }
 
@@ -2556,12 +2706,14 @@ void EventSender::ReplaySavedEvents() {
       case SavedEvent::TYPE_MOUSE_MOVE: {
         WebMouseEvent event;
         InitMouseEvent(WebInputEvent::MouseMove,
-                       pressed_button_,
-                       current_buttons_,
+                       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);
         DoMouseMove(event);
         break;
@@ -2570,17 +2722,21 @@ void EventSender::ReplaySavedEvents() {
         DoLeapForward(e.milliseconds);
         break;
       case SavedEvent::TYPE_MOUSE_UP: {
-        current_buttons_ &= ~GetWebMouseEventModifierForButton(e.button_type);
-        pressed_button_ = WebMouseEvent::ButtonNone;
+        current_pointer_state_[kMousePointerId].current_buttons_ &=
+            ~GetWebMouseEventModifierForButton(e.button_type);
+        current_pointer_state_[kMousePointerId].pressed_button_ =
+            WebMouseEvent::ButtonNone;
 
         WebMouseEvent event;
         InitMouseEvent(WebInputEvent::MouseUp,
                        e.button_type,
-                       current_buttons_,
-                       last_mouse_pos_,
+                       current_pointer_state_[kMousePointerId].current_buttons_,
+                       current_pointer_state_[kMousePointerId].last_pos_,
                        GetCurrentEventTimeSec(),
                        click_count_,
                        e.modifiers,
+                       blink::WebPointerProperties::PointerType::Mouse,
+                       0,
                        &event);
         DoMouseUp(event);
         break;