Consider isPrimary and pointerType when preventing compat mouse

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/command_line.h"
 #include "base/logging.h"
@@ skipping 40 matching lines @@
 using blink::WebString;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using blink::WebVector;
 using blink::WebView;
 
 namespace test_runner {
 
 namespace {
 
+const char* kPointerTypeStringUnknown = "";
+const char* kPointerTypeStringMouse = "mouse";
+const char* kPointerTypeStringPen = "pen";
+const char* kPointerTypeStringTouch = "touch";
+
+bool getPointerType(gin::Arguments* args,
+                    blink::WebPointerProperties::PointerType &t) {
+    if (!args->PeekNext().IsEmpty()) {
+      std::string pointer_type_string;
+      if (!args->GetNext(&pointer_type_string)) {
+        args->ThrowError();
+        return true;
+      }
+      if (pointer_type_string == kPointerTypeStringUnknown) {
+        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) {
+        t = WebMouseEvent::PointerType::Touch;
+      } else {
+        args->ThrowError();
+        return true;
+      }
+    }
+    return false;
+}
+
 WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) {
   switch (button_code) {
     case -1:
       return WebMouseEvent::ButtonNone;
     case 0:
       return WebMouseEvent::ButtonLeft;
     case 1:
       return WebMouseEvent::ButtonMiddle;
     case 2:
       return WebMouseEvent::ButtonRight;
@@ skipping 25 matching lines @@
       | (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) {
   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 = blink::WebPointerProperties::PointerType::Mouse;
+  e->pointerType = pointerType;
+  e->id = pointerId;
   e->timeStampSeconds = time_stamp;
   e->clickCount = click_count;
 }
 
 void InitGestureEventFromMouseWheel(WebInputEvent::Type type,
                                     double time_stamp,
                                     const WebMouseWheelEvent& wheel_event,
                                     WebGestureEvent* gesture_event) {
   gesture_event->type = type;
   gesture_event->sourceDevice = blink::WebGestureDeviceTouchpad;
@@ skipping 323 matching lines @@
     }
   } else {
     *units = WebGestureEvent::PrecisePixels;
     return true;
   }
 }
 
 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> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<EventSender> sender,
                       blink::WebFrame* frame);
 
  private:
@@ skipping 498 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 type =
+      blink::WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
   if (!args->PeekNext().IsEmpty()) {
     args->GetNext(&button_number);
-    if (!args->PeekNext().IsEmpty())
+    if (!args->PeekNext().IsEmpty()) {
       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
+      args->Skip();
+    }
   }
-  sender_->MouseDown(button_number, modifiers);
+  getPointerType(args, type);
+  if (!args->PeekNext().IsEmpty())
+    args->GetNext(&pointerId);
+
+  // Only allow pen or mouse through this API;
+  if (type != blink::WebPointerProperties::PointerType::Mouse
+      && type != blink::WebPointerProperties::PointerType::Pen)
+      type = blink::WebPointerProperties::PointerType::Mouse;
+
+  sender_->MouseDown(button_number, modifiers, type, pointerId);
 }
 
 void EventSenderBindings::MouseUp(gin::Arguments* args) {
   if (!sender_)
     return;
 
   int button_number = 0;
   int modifiers = 0;
+  blink::WebPointerProperties::PointerType type =
+      blink::WebPointerProperties::PointerType::Mouse;
+  int pointerId = 0;
   if (!args->PeekNext().IsEmpty()) {
     args->GetNext(&button_number);
-    if (!args->PeekNext().IsEmpty())
+    if (!args->PeekNext().IsEmpty()) {
       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
+      args->Skip();
+    }
   }
-  sender_->MouseUp(button_number, modifiers);
+  getPointerType(args, type);

[dtapuska, 2016/04/05 19:21:25]

This API returns a bool... should we handle the return?

[Navid Zolghadr, 2016/04/05 20:17:25]

I wanted to do that too. However this function was not error checking itself for
the button_number. So I thought it would be odd to only handle it here. I added
the error check for the previous field as well. Is that okay?

[dtapuska, 2016/04/05 20:30:40]

looks good.

+  if (!args->PeekNext().IsEmpty())
+    args->GetNext(&pointerId);
+
+  // Only allow pen or mouse through this API;
+  if (type != blink::WebPointerProperties::PointerType::Mouse

[dtapuska, 2016/04/05 19:21:24]

Personally I think a switch is easier to read. Also comment is an incomplete
sentence terminating with a ";"

[Navid Zolghadr, 2016/04/05 20:17:25]

I changed the way I handle this. I moved it to getPointerType function and
return error in any other case rather than silently overriding it. Is that
better or am I misusing that error here?

[dtapuska, 2016/04/05 20:30:40]

Seems reasonable to me.

+      && type != blink::WebPointerProperties::PointerType::Pen)
+      type = blink::WebPointerProperties::PointerType::Mouse;
+
+  sender_->MouseUp(button_number, modifiers, type, pointerId);
 }
 
 void EventSenderBindings::SetMouseButtonState(gin::Arguments* args) {
   if (!sender_)
     return;
 
   int button_number;
   if (!args->GetNext(&button_number)) {
     args->ThrowError();
     return;
@@ skipping 185 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_ && pressed_button_ != WebMouseEvent::ButtonNone)
     view_->mouseCaptureLost();
+  stateOfPen.clear();
   pressed_button_ = WebMouseEvent::ButtonNone;
   current_buttons_ = 0;
   modifiers_ = 0;
   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 41 matching lines @@
 void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseDown,
                  pressed_button_,
                  current_buttons_,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  modifiers_,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &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(modifiers_, 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();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
-  UpdateClickCountForButton(button_type);
+  WebMouseEvent event;
+  if (pointerType == blink::WebPointerProperties::PointerType::Mouse) {
+    UpdateClickCountForButton(button_type);
 
-  pressed_button_ = button_type;
-  current_buttons_ |= GetWebMouseEventModifierForButton(pressed_button_);
-  modifiers_ = modifiers;
+    pressed_button_ = button_type;
+    current_buttons_ |= GetWebMouseEventModifierForButton(pressed_button_);
+    modifiers_ = modifiers;
+    InitMouseEvent(WebInputEvent::MouseDown,
+                   pressed_button_,

[dtapuska, 2016/04/05 19:21:25]

Would it make sense to store some of this in the stateOfPen map? but just have a
special pointerId value for the mouse?

[Navid Zolghadr, 2016/04/05 20:17:25]

I'd like to do that too as it is pretty much the same state. Although they are
all static but I don't think there is any problem removing their static
modifier.
If I do that I need to either prevent this API to get that particular mouse id
for the pen or just remove the id from the input altogether and assign the ids
myself in event_sender similar to the touch ids. Which way do you think is
better?

[dtapuska, 2016/04/05 20:30:40]

The current_pen_state_ is a unordered_map; so I'd use an integer that isn't
expected to be a pointer id.. Is there an explicit range? It's up to you if you
allow pointerIds to be assigned by the event sender; I don't have strong
feelings either way.

+                   current_buttons_,
+                   last_mouse_pos_,
+                   GetCurrentEventTimeSec(),
+                   click_count_,
+                   modifiers_,
+                   pointerType,
+                   0,
+                   &event);
+  } else {
+    stateOfPen[pointerId].pressed_button_ = button_type;
+    stateOfPen[pointerId].current_buttons_ |=
+      GetWebMouseEventModifierForButton(pressed_button_);
+    stateOfPen[pointerId].modifiers_ = modifiers;
+    InitMouseEvent(WebInputEvent::MouseDown,
+                   stateOfPen[pointerId].pressed_button_,
+                   stateOfPen[pointerId].current_buttons_,
+                   stateOfPen[pointerId].last_pos_,
+                   GetCurrentEventTimeSec(),
+                   0,
+                   modifiers_,
+                   pointerType,
+                   pointerId,
+                   &event);
+  }
 
-  WebMouseEvent event;
-  InitMouseEvent(WebInputEvent::MouseDown,
-                 pressed_button_,
-                 current_buttons_,
-                 last_mouse_pos_,
-                 GetCurrentEventTimeSec(),
-                 click_count_,
-                 modifiers_,
-                 &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();
 
   DCHECK_NE(-1, button_number);
 
   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_buttons_ &= ~GetWebMouseEventModifierForButton(button_type);
+      pressed_button_ = WebMouseEvent::ButtonNone;
+
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseUp,
+                     button_type,
+                     current_buttons_,
+                     last_mouse_pos_,
+                     GetCurrentEventTimeSec(),
+                     click_count_,
+                     modifiers,
+                     pointerType,
+                     0,
+                     &event);
+      DoMouseUp(event);
+    }
   } else {
-    current_buttons_ &= ~GetWebMouseEventModifierForButton(button_type);
-    pressed_button_ = WebMouseEvent::ButtonNone;
+      stateOfPen[pointerId].current_buttons_ &=
+          ~GetWebMouseEventModifierForButton(button_type);
+      stateOfPen[pointerId].pressed_button_ = WebMouseEvent::ButtonNone;
 
-    WebMouseEvent event;
-    InitMouseEvent(WebInputEvent::MouseUp,
-                   button_type,
-                   current_buttons_,
-                   last_mouse_pos_,
-                   GetCurrentEventTimeSec(),
-                   click_count_,
-                   modifiers,
-                   &event);
-    DoMouseUp(event);
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseUp,
+                     button_type,
+                     stateOfPen[pointerId].current_buttons_,
+                     stateOfPen[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_) :
       modifiers & kButtonsInModifiers;
 }
 
@@ skipping 193 matching lines @@
 
   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
     WebMouseEvent event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    pressed_button_,
                    current_buttons_,
                    last_mouse_pos_,
                    GetCurrentEventTimeSec(),
                    click_count_,
                    0,
+                   blink::WebPointerProperties::PointerType::Mouse,
+                   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.
@@ skipping 35 matching lines @@
     pressed_button_ = WebMouseEvent::ButtonRight;
     current_buttons_ |= GetWebMouseEventModifierForButton(pressed_button_);
   }
   InitMouseEvent(WebInputEvent::MouseDown,
                  WebMouseEvent::ButtonRight,
                  current_buttons_,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 
 #if defined(OS_WIN)
   current_buttons_ &=
       ~GetWebMouseEventModifierForButton(WebMouseEvent::ButtonRight);
   pressed_button_ = WebMouseEvent::ButtonNone;
 
   InitMouseEvent(WebInputEvent::MouseUp,
                  WebMouseEvent::ButtonRight,
                  current_buttons_,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 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;
 }
 
@@ skipping 333 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();
+  }
+
+  getPointerType(args, pointerType);

[dtapuska, 2016/04/05 19:21:25]

same comments regarding return type.

[Navid Zolghadr, 2016/04/05 20:17:25]

Done.

+
   if (!args->PeekNext().IsEmpty())
-    modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
+    args->GetNext(&pointerId);
 
-  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 (pointerType == blink::WebPointerProperties::PointerType::Mouse) {
+    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);
+    } else {
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseMove,
+                     pressed_button_,
+                     current_buttons_,
+                     mouse_pos,
+                     GetCurrentEventTimeSec(),
+                     click_count_,
+                     modifiers,
+                     pointerType,
+                     0,
+                     &event);
+      DoMouseMove(event);
+    }
   } else {
-    WebMouseEvent event;
-    InitMouseEvent(WebInputEvent::MouseMove,
-                   pressed_button_,
-                   current_buttons_,
-                   mouse_pos,
-                   GetCurrentEventTimeSec(),
-                   click_count_,
-                   modifiers,
-                   &event);
-    DoMouseMove(event);
+      stateOfPen[pointerId].last_pos_ = mouse_pos;
+
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseMove,
+                     stateOfPen[pointerId].pressed_button_,
+                     stateOfPen[pointerId].current_buttons_,
+                     mouse_pos,
+                     GetCurrentEventTimeSec(),
+                     0,
+                     modifiers,
+                     pointerType,
+                     pointerId,
+                     &event);
+      HandleInputEventOnViewOrPopup(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
     view_->updateAllLifecyclePhases();
 
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseLeave,
                  WebMouseEvent::ButtonNone,
                  0,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  0,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate_->PostTask(new MouseDownTask(this, button_number, modifiers));
   delegate_->PostTask(new MouseUpTask(this, button_number, modifiers));
 }
 
@@ skipping 297 matching lines @@
   // 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,
                    pressed_button_,
                    current_buttons_,
                    WebPoint(x, y),
                    GetCurrentEventTimeSec(),
                    click_count_,
                    modifiers_,
+                   blink::WebPointerProperties::PointerType::Mouse,
+                   0,
                    &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_ <
@@ skipping 51 matching lines @@
     *send_gestures = true;
   }
 
   InitMouseEvent(WebInputEvent::MouseWheel,
                  pressed_button_,
                  current_buttons_,
                  last_mouse_pos_,
                  GetCurrentEventTimeSec(),
                  click_count_,
                  modifiers,
+                 blink::WebPointerProperties::PointerType::Mouse,
+                 0,
                  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;
@@ skipping 42 matching lines @@
   if (!args->PeekNext().IsEmpty()) {
     int tiltX, tiltY;
     if (!args->GetNext(&tiltX) || !args->GetNext(&tiltY)) {
       args->ThrowError();
       return;
     }
     e->tiltX = tiltX;
     e->tiltY = tiltY;
   }
 
-  if (!args->PeekNext().IsEmpty()) {
-    std::string pointer_type_string;
-    if (!args->GetNext(&pointer_type_string)) {
-      args->ThrowError();
+  if (getPointerType(args, e->pointerType)) {
       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;
-    }
   }
 }
 
 void EventSender::FinishDragAndDrop(const WebMouseEvent& e,
                                      blink::WebDragOperation drag_effect) {
   WebPoint client_point(e.x, e.y);
   WebPoint screen_point(e.globalX, e.globalY);
   current_drag_effect_ = drag_effect;
   if (current_drag_effect_) {
     // Specifically pass any keyboard modifiers to the drop method. This allows
@@ skipping 58 matching lines @@
     switch (e.type) {
       case SavedEvent::TYPE_MOUSE_MOVE: {
         WebMouseEvent event;
         InitMouseEvent(WebInputEvent::MouseMove,
                        pressed_button_,
                        current_buttons_,
                        e.pos,
                        GetCurrentEventTimeSec(),
                        click_count_,
                        e.modifiers,
+                       blink::WebPointerProperties::PointerType::Mouse,
+                       0,
                        &event);
         DoMouseMove(event);
         break;
       }
       case SavedEvent::TYPE_LEAP_FORWARD:
         DoLeapForward(e.milliseconds);
         break;
       case SavedEvent::TYPE_MOUSE_UP: {
         current_buttons_ &= ~GetWebMouseEventModifierForButton(e.button_type);
         pressed_button_ = WebMouseEvent::ButtonNone;
 
         WebMouseEvent event;
         InitMouseEvent(WebInputEvent::MouseUp,
                        e.button_type,
                        current_buttons_,
                        last_mouse_pos_,
                        GetCurrentEventTimeSec(),
                        click_count_,
                        e.modifiers,
+                       blink::WebPointerProperties::PointerType::Mouse,
+                       0,
                        &event);
         DoMouseUp(event);
         break;
       }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
@@ skipping 61 matching lines @@
                                  &end_event);
   end_event.data.scrollEnd.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     view_->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(end_event);
 }
 
 }  // namespace test_runner