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";
+

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

I'd invert the function to return false on failure; true on success..

[Navid Zolghadr, 2016/04/06 15:27:10]

Sure

+bool getPointerType(gin::Arguments* args,
+                    blink::WebPointerProperties::PointerType &t,
+                    bool isOnlyMouseAndPenAllowed = false) {
+    if (!args->PeekNext().IsEmpty()) {
+      std::string pointer_type_string;
+      if (!args->GetNext(&pointer_type_string)) {
+        args->ThrowError();
+        return true;
+      }
+      if (pointer_type_string == kPointerTypeStringUnknown) {
+        if (isOnlyMouseAndPenAllowed) {
+          args->ThrowError();
+          return true;
+        }
+        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 true;
+        }
+        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 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);
+
+  // Only allow pen or mouse through this API.
+  if (getPointerType(args, pointerType, true))
+    return;
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&pointerId)) {
+      args->ThrowError();
+      return;
+    }
+  }
+
+  sender_->MouseDown(button_number, modifiers, pointerType, pointerId);
 }
 
 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()) {
-    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);
+
+  // Only allow pen or mouse through this API.
+  if (getPointerType(args, pointerType))
+    return;
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&pointerId)) {
+      args->ThrowError();
+      return;
+    }
+  }
+
+  sender_->MouseUp(button_number, modifiers, pointerType, 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();
+  current_pen_state_.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_,
+                   current_buttons_,
+                   last_mouse_pos_,
+                   GetCurrentEventTimeSec(),
+                   click_count_,
+                   modifiers_,
+                   pointerType,
+                   0,
+                   &event);
+  } else {
+    current_pen_state_[pointerId].pressed_button_ = button_type;
+    current_pen_state_[pointerId].current_buttons_ |=
+      GetWebMouseEventModifierForButton(pressed_button_);
+    current_pen_state_[pointerId].modifiers_ = modifiers;
+    InitMouseEvent(WebInputEvent::MouseDown,
+                   current_pen_state_[pointerId].pressed_button_,
+                   current_pen_state_[pointerId].current_buttons_,
+                   current_pen_state_[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;
+      current_pen_state_[pointerId].current_buttons_ &=
+          ~GetWebMouseEventModifierForButton(button_type);
+      current_pen_state_[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,
+                     current_pen_state_[pointerId].current_buttons_,
+                     current_pen_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_) :
       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())
+  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);
+  // Only allow pen or mouse through this API.
+  if (getPointerType(args, pointerType, true))
+    return;
+  if (!args->PeekNext().IsEmpty()) {
+    if (!args->GetNext(&pointerId)) {
+      args->ThrowError();
+      return;
+    }
+  }
+
+  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);
+      current_pen_state_[pointerId].last_pos_ = mouse_pos;
+
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseMove,
+                     current_pen_state_[pointerId].pressed_button_,
+                     current_pen_state_[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();
-      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,
                                      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
     // tests to control the drop type (i.e. copy or move).
@@ skipping 57 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