Add constructors to WebInputEvents and setters so we can work at cleaning up these public structs.

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 <memory>
 
@@ skipping 182 matching lines @@
 }
 
 const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown
     | WebMouseEvent::MiddleButtonDown | WebMouseEvent::RightButtonDown;
 
 int modifiersWithButtons(int modifiers, int buttons) {
   return (modifiers & ~kButtonsInModifiers)
       | (buttons & kButtonsInModifiers);
 }
 
-void InitMouseEventGeneric(WebInputEvent::Type t,
-                           WebMouseEvent::Button b,
+void InitMouseEventGeneric(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,
+void InitMouseEvent(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);
+  InitMouseEventGeneric(b, current_buttons, pos, click_count,
+                        WebPointerProperties::PointerType::Mouse, 0, 0.0, 0, 0,
+                        e);
 }
 
-void InitGestureEventFromMouseWheel(WebInputEvent::Type type,
-                                    double time_stamp,
-                                    const WebMouseWheelEvent& wheel_event,
+void InitGestureEventFromMouseWheel(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;
-  gesture_event->timeStampSeconds = time_stamp;
 }
 
 int GetKeyModifier(const std::string& modifier_name) {
   const char* characters = modifier_name.c_str();
   if (!strcmp(characters, "ctrlKey")
 #ifndef __APPLE__
       || !strcmp(characters, "addSelectionKey")
 #endif
       ) {
     return WebInputEvent::ControlKey;
@@ skipping 1071 matching lines @@
 }
 
 void EventSender::Install(WebLocalFrame* frame) {
   EventSenderBindings::Install(weak_factory_.GetWeakPtr(), frame);
 }
 
 void EventSender::SetContextMenuData(const WebContextMenuData& data) {
   last_context_menu_data_.reset(new WebContextMenuData(data));
 }
 
+int EventSender::ModifiersForPointer(int pointer_id) {
+  return modifiersWithButtons(
+      current_pointer_state_[pointer_id].modifiers_,
+      current_pointer_state_[pointer_id].current_buttons_);
+}
+
 void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
-  WebMouseEvent raw_event;
-  InitMouseEvent(WebInputEvent::MouseDown,
-                 current_pointer_state_[kRawMousePointerId].pressed_button_,
+  WebMouseEvent raw_event(WebInputEvent::MouseDown,
+                          ModifiersForPointer(kRawMousePointerId),
+                          GetCurrentEventTimeSec());
+  InitMouseEvent(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_,
-                 &raw_event);
+                 click_count_, &raw_event);
 
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebMouseEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
 
   WebPoint client_point(event->x, event->y);
   WebPoint screen_point(event->globalX, event->globalY);
   current_drag_data_ = drag_data;
@@ skipping 27 matching lines @@
                               int tiltX,
                               int tiltY) {
   if (force_layout_on_events_)
     widget()->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 == WebPointerProperties::PointerType::Mouse) {
     UpdateClickCountForButton(button_type);
     click_count = click_count_;
   }
-  InitMouseEventGeneric(WebInputEvent::MouseDown,
-                        current_pointer_state_[pointerId].pressed_button_,
+  WebMouseEvent event(WebInputEvent::MouseDown, ModifiersForPointer(pointerId),
+                      GetCurrentEventTimeSec());
+  InitMouseEventGeneric(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);
+                        click_count, pointerType, pointerId, pressure, tiltX,
+                        tiltY, &event);
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::PointerUp(int button_number,
                             int modifiers,
                             WebPointerProperties::PointerType pointerType,
                             int pointerId,
                             float pressure,
                             int tiltX,
                             int tiltY) {
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   DCHECK_NE(-1, button_number);
 
   WebMouseEvent::Button button_type =
       GetButtonTypeFromButtonNumber(button_number);
 
   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].modifiers_ = modifiers;
     current_pointer_state_[pointerId].current_buttons_ &=
         ~GetWebMouseEventModifierForButton(button_type);
     current_pointer_state_[pointerId].pressed_button_ =
         WebMouseEvent::Button::NoButton;
 
-    WebMouseEvent event;
+    WebMouseEvent event(WebInputEvent::MouseUp, ModifiersForPointer(pointerId),
+                        GetCurrentEventTimeSec());
     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);
+    InitMouseEventGeneric(
+        button_type, current_pointer_state_[pointerId].current_buttons_,
+        current_pointer_state_[pointerId].last_pos_, click_count, pointerType,
+        pointerId, pressure, tiltX, tiltY, &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseUp(event);
   }
 }
 
 void EventSender::SetMouseButtonState(int button_number, int modifiers) {
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
       GetButtonTypeFromButtonNumber(button_number);
   current_pointer_state_[kRawMousePointerId].current_buttons_ =
@@ skipping 171 matching lines @@
     }
 
     if ("(" == code_str) {
       code = '9';
       needs_shift_key_modifier = true;
       domKeyString.assign("(");
       domCodeString.assign("Digit9");
     }
   }
 
+  if (needs_shift_key_modifier)
+    modifiers |= WebInputEvent::ShiftKey;
+
+  // See if KeyLocation argument is given.
+  switch (location) {
+    case DOMKeyLocationStandard:
+      break;
+    case DOMKeyLocationLeft:
+      modifiers |= WebInputEvent::IsLeft;
+      break;
+    case DOMKeyLocationRight:
+      modifiers |= WebInputEvent::IsRight;
+      break;
+    case DOMKeyLocationNumpad:
+      modifiers |= WebInputEvent::IsKeyPad;
+      break;
+  }
+
   // For one generated keyboard event, we need to generate a keyDown/keyUp
   // pair;
   // On Windows, we might also need to generate a char event to mimic the
   // Windows event flow; on other platforms we create a merged event and test
   // the event flow that that platform provides.
-  WebKeyboardEvent event_down;
-  event_down.timeStampSeconds = GetCurrentEventTimeSec();
-  event_down.type = WebInputEvent::RawKeyDown;
-  event_down.modifiers = modifiers;
+  WebKeyboardEvent event_down(WebInputEvent::RawKeyDown, modifiers,
+                              GetCurrentEventTimeSec());
   event_down.windowsKeyCode = code;
   event_down.domKey = static_cast<int>(
       ui::KeycodeConverter::KeyStringToDomKey(domKeyString));
   event_down.domCode = static_cast<int>(
       ui::KeycodeConverter::CodeStringToDomCode(domCodeString));
 
   if (generate_char) {
     event_down.text[0] = text;
     event_down.unmodifiedText[0] = text;
   }
 
   if (event_down.modifiers != 0)
     event_down.isSystemKey = IsSystemKeyEvent(event_down);
 
-  if (needs_shift_key_modifier)
-    event_down.modifiers |= WebInputEvent::ShiftKey;
-
-  // See if KeyLocation argument is given.
-  switch (location) {
-  case DOMKeyLocationStandard:
-    break;
-  case DOMKeyLocationLeft:
-    event_down.modifiers |= WebInputEvent::IsLeft;
-    break;
-  case DOMKeyLocationRight:
-    event_down.modifiers |= WebInputEvent::IsRight;
-    break;
-  case DOMKeyLocationNumpad:
-    event_down.modifiers |= WebInputEvent::IsKeyPad;
-    break;
-  }
-
-  WebKeyboardEvent event_up;
-  event_up = event_down;
-  event_up.type = WebInputEvent::KeyUp;
+  WebKeyboardEvent event_up = event_down;
+  event_up.setType(WebInputEvent::KeyUp);
   // EventSender.m forces a layout here, with at least one
   // test (fast/forms/focus-control-to-page.html) relying on this.
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   // In the browser, if a keyboard event corresponds to an editor command,
   // the command will be dispatched to the renderer just before dispatching
   // the keyboard event, and then it will be executed in the
   // RenderView::handleCurrentKeyboardEvent() method.
   // 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_[kRawMousePointerId].pressed_button_,
+    WebMouseEvent event(WebInputEvent::MouseDown,
+                        ModifiersForPointer(kRawMousePointerId),
+                        GetCurrentEventTimeSec());
+    InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
                    current_pointer_state_[kRawMousePointerId].current_buttons_,
                    current_pointer_state_[kRawMousePointerId].last_pos_,
-                   GetCurrentEventTimeSec(), click_count_, 0, &event);
+                   click_count_, &event);
     FinishDragAndDrop(event, blink::WebDragOperationNone);
   }
 
   delegate()->ClearEditCommand();
 
   if (generate_char) {
     WebKeyboardEvent event_char = event_up;
-    event_char.type = WebInputEvent::Char;
+    event_char.setType(WebInputEvent::Char);
     HandleInputEventOnViewOrPopup(event_char);
   }
 
   HandleInputEventOnViewOrPopup(event_up);
 }
 
 void EventSender::EnableDOMUIEventLogging() {}
 
 void EventSender::FireKeyboardEventsToElement() {}
 
 void EventSender::ClearKillRing() {}
 
 std::vector<std::string> EventSender::ContextClick() {
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   UpdateClickCountForButton(WebMouseEvent::Button::Right);
 
   // Clears last context menu data because we need to know if the context menu
   // 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_[kRawMousePointerId].pressed_button_ ==
       WebMouseEvent::Button::NoButton) {
     current_pointer_state_[kRawMousePointerId].pressed_button_ =
         WebMouseEvent::Button::Right;
     current_pointer_state_[kRawMousePointerId].current_buttons_ |=
         GetWebMouseEventModifierForButton(
             current_pointer_state_[kRawMousePointerId].pressed_button_);
   }
-  InitMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::Button::Right,
+  WebMouseEvent event(WebInputEvent::MouseDown,
+                      ModifiersForPointer(kRawMousePointerId),
+                      GetCurrentEventTimeSec());
+  InitMouseEvent(WebMouseEvent::Button::Right,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, 0, &event);
+                 click_count_, &event);
   HandleInputEventOnViewOrPopup(event);
 
 #if defined(OS_WIN)
   current_pointer_state_[kRawMousePointerId].current_buttons_ &=
       ~GetWebMouseEventModifierForButton(WebMouseEvent::Button::Right);
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
       WebMouseEvent::Button::NoButton;
 
-  InitMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::Button::Right,
+  WebMouseEvent mouseUpEvent(WebInputEvent::MouseUp,
+                             ModifiersForPointer(kRawMousePointerId),
+                             GetCurrentEventTimeSec());
+  InitMouseEvent(WebMouseEvent::Button::Right,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, 0, &event);
-  HandleInputEventOnViewOrPopup(event);
+                 click_count_, &mouseUpEvent);
+  HandleInputEventOnViewOrPopup(mouseUpEvent);
 #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() {
   view()->setTextZoomFactor(view()->textZoomFactor() * 1.2f);
@@ skipping 105 matching lines @@
     if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
       filename = items[i].title;
       break;
     }
   }
   delegate()->PrintMessage(std::string("Filename being dragged: ") +
                            filename.utf8().data() + "\n");
 }
 
 void EventSender::GestureFlingCancel() {
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureFlingCancel;
+  WebGestureEvent event(WebInputEvent::GestureFlingCancel,
+                        WebInputEvent::NoModifiers, GetCurrentEventTimeSec());
   // Generally it won't matter what device we use here, and since it might
   // be cumbersome to expect all callers to specify a device, we'll just
   // choose Touchpad here.
   event.sourceDevice = blink::WebGestureDeviceTouchpad;
-  event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::GestureFlingStart(float x,
                                     float y,
                                     float velocity_x,
                                     float velocity_y,
                                     gin::Arguments* args) {
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureFlingStart;
+  WebGestureEvent event(WebInputEvent::GestureFlingStart,
+                        WebInputEvent::NoModifiers, GetCurrentEventTimeSec());
 
   std::string device_string;
   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString())
     args->GetNext(&device_string);
 
   if (device_string == kSourceDeviceStringTouchpad) {
     event.sourceDevice = blink::WebGestureDeviceTouchpad;
   } else if (device_string == kSourceDeviceStringTouchscreen) {
     event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   } else {
     args->ThrowError();
     return;
   }
 
   float max_start_velocity = std::max(fabs(velocity_x), fabs(velocity_y));
   if (!max_start_velocity) {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     isolate->ThrowException(v8::Exception::TypeError(
       gin::StringToV8(isolate, "Invalid max start velocity.")));
     return;
   }
 
   event.x = x;
   event.y = y;
   event.globalX = event.x;
   event.globalY = event.y;
 
   event.data.flingStart.velocityX = velocity_x;
   event.data.flingStart.velocityY = velocity_y;
-  event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 bool EventSender::IsFlinging() const {
   return view()->isFlinging();
 }
@@ skipping 12 matching lines @@
 
 void EventSender::TouchCancel(gin::Arguments* args) {
   SendCurrentTouchEvent(WebInputEvent::TouchCancel, args);
 }
 
 void EventSender::TouchEnd(gin::Arguments* args) {
   SendCurrentTouchEvent(WebInputEvent::TouchEnd, args);
 }
 
 void EventSender::NotifyStartOfTouchScroll() {
-  WebTouchEvent event;
-  event.type = WebInputEvent::TouchScrollStarted;
+  WebTouchEvent event(WebInputEvent::TouchScrollStarted,
+                      WebInputEvent::NoModifiers, GetCurrentEventTimeSec());
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::LeapForward(int milliseconds) {
   if (is_drag_mode_ &&
       current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::Button::Left &&
       !replaying_saved_events_) {
     SavedEvent saved_event;
     saved_event.type = SavedEvent::TYPE_LEAP_FORWARD;
@@ skipping 120 matching lines @@
 void EventSender::GestureLongTap(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureLongTap, args);
 }
 
 void EventSender::GestureTwoFingerTap(gin::Arguments* args) {
   GestureEvent(WebInputEvent::GestureTwoFingerTap, args);
 }
 
 void EventSender::MouseScrollBy(gin::Arguments* args,
                                 MouseScrollType scroll_type) {
-  WebMouseWheelEvent wheel_event;
   // TODO(dtapuska): Gestures really should be sent by the MouseWheelEventQueue
   // class in the browser. But since the event doesn't propogate up into
   // the browser generate the events here. See crbug.com/596095.
   bool send_gestures = true;
-  InitMouseWheelEvent(args, scroll_type, &wheel_event, &send_gestures);
-  if (HandleInputEventOnViewOrPopup(wheel_event) ==
+  WebMouseWheelEvent wheel_event =
+      GetMouseWheelEvent(args, scroll_type, &send_gestures);
+  if (wheel_event.type != WebInputEvent::Undefined &&
+      HandleInputEventOnViewOrPopup(wheel_event) ==
           WebInputEventResult::NotHandled &&
       send_gestures) {
     SendGesturesForMouseWheelEvent(wheel_event);
   }
 }
 
 void EventSender::MouseMoveTo(gin::Arguments* args) {
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
@@ skipping 25 matching lines @@
       is_drag_mode_ && !replaying_saved_events_ &&
       current_pointer_state_[kRawMousePointerId].pressed_button_ ==
           WebMouseEvent::Button::Left) {
     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;
+    current_pointer_state_[pointerId].modifiers_ = modifiers;
+    WebMouseEvent event(WebInputEvent::MouseMove,
+                        ModifiersForPointer(pointerId),
+                        GetCurrentEventTimeSec());
     int click_count = pointerType == WebPointerProperties::PointerType::Mouse
                           ? click_count_
                           : 0;
     InitMouseEventGeneric(
-        WebInputEvent::MouseMove,
         current_pointer_state_[kRawMousePointerId].pressed_button_,
         current_pointer_state_[kRawMousePointerId].current_buttons_, mouse_pos,
-        GetCurrentEventTimeSec(), click_count, modifiers, pointerType,
-        pointerId, pressure, tiltX, tiltY, &event);
+        click_count, pointerType, pointerId, pressure, tiltX, tiltY, &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseMove(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
-  WebMouseEvent event;
-  InitMouseEvent(WebInputEvent::MouseLeave, WebMouseEvent::Button::NoButton, 0,
+  WebMouseEvent event(WebInputEvent::MouseLeave,
+                      ModifiersForPointer(kRawMousePointerId),
+                      GetCurrentEventTimeSec());
+  InitMouseEvent(WebMouseEvent::Button::NoButton, 0,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, 0, &event);
+                 click_count_, &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate()->PostTask(base::Bind(&EventSender::MouseDown,
                                   weak_factory_.GetWeakPtr(), button_number,
                                   modifiers));
   delegate()->PostTask(base::Bind(&EventSender::MouseUp,
                                   weak_factory_.GetWeakPtr(), button_number,
@@ skipping 45 matching lines @@
                                         gin::Arguments* args) {
   bool moved_beyond_slop_region;
   uint32_t unique_touch_event_id;
   GetOptionalTouchArgs(args, moved_beyond_slop_region, unique_touch_event_id);
 
   DCHECK_GT(static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap),
             touch_points_.size());
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
-  WebTouchEvent touch_event;
-  touch_event.type = type;
-  touch_event.modifiers = touch_modifiers_;
+  WebTouchEvent touch_event(type, touch_modifiers_, GetCurrentEventTimeSec());
   touch_event.dispatchType = touch_cancelable_
                                  ? WebInputEvent::Blocking
                                  : WebInputEvent::EventNonBlocking;
-  touch_event.timeStampSeconds = GetCurrentEventTimeSec();
   touch_event.movedBeyondSlopRegion = moved_beyond_slop_region;
   touch_event.uniqueTouchEventId = unique_touch_event_id;
   touch_event.touchesLength = touch_points_.size();
   for (size_t i = 0; i < touch_points_.size(); ++i)
     touch_event.touches[i] = touch_points_[i];
   HandleInputEventOnViewOrPopup(touch_event);
 
   for (size_t i = 0; i < touch_points_.size(); ++i) {
     WebTouchPoint* touch_point = &touch_points_[i];
     if (touch_point->state == WebTouchPoint::StateReleased
         || touch_point->state == WebTouchPoint::StateCancelled) {
       touch_points_.erase(touch_points_.begin() + i);
       --i;
     } else {
       touch_point->state = WebTouchPoint::StateStationary;
     }
   }
 }
 
 void EventSender::GestureEvent(WebInputEvent::Type type,
                                gin::Arguments* args) {
-  WebGestureEvent event;
-  event.type = type;
+  WebGestureEvent event(type, WebInputEvent::NoModifiers,
+                        GetCurrentEventTimeSec());
 
   // If the first argument is a string, it is to specify the device, otherwise
   // the device is assumed to be a touchscreen (since most tests were written
   // assuming this).
   event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) {
     std::string device_string;
     if (!args->GetNext(&device_string)) {
       args->ThrowError();
       return;
@@ skipping 204 matching lines @@
       }
       break;
     default:
       NOTREACHED();
   }
 
   event.uniqueTouchEventId = GetUniqueTouchEventId(args);
 
   event.globalX = event.x;
   event.globalY = event.y;
-  event.timeStampSeconds = GetCurrentEventTimeSec();
 
   if (force_layout_on_events_)
     widget()->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_[kRawMousePointerId].pressed_button_,
+    WebMouseEvent mouse_event(WebInputEvent::MouseDown,
+                              ModifiersForPointer(kRawMousePointerId),
+                              GetCurrentEventTimeSec());
+
+    InitMouseEvent(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);
+                   WebPoint(x, y), click_count_, &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_[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,
-                                      MouseScrollType scroll_type,
-                                      WebMouseWheelEvent* event,
-                                      bool* send_gestures) {
+WebMouseWheelEvent EventSender::GetMouseWheelEvent(gin::Arguments* args,
+                                                   MouseScrollType scroll_type,
+                                                   bool* send_gestures) {
   // Force a layout here just to make sure every position has been
   // determined before we send events (as well as all the other methods
   // that send an event do).
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   double horizontal;
-  if (!args->GetNext(&horizontal)) {
+  double vertical;
+  if (!args->GetNext(&horizontal) || !args->GetNext(&vertical)) {
     args->ThrowError();
-    return;
-  }
-  double vertical;
-  if (!args->GetNext(&vertical)) {
-    args->ThrowError();
-    return;
+    return WebMouseWheelEvent();
   }
 
   bool paged = false;
   bool has_precise_scrolling_deltas = false;
   int modifiers = 0;
   WebMouseWheelEvent::Phase phase = WebMouseWheelEvent::PhaseNone;
   if (!args->PeekNext().IsEmpty()) {
     args->GetNext(&paged);
     if (!args->PeekNext().IsEmpty()) {
       args->GetNext(&has_precise_scrolling_deltas);
       if (!args->PeekNext().IsEmpty()) {
         v8::Local<v8::Value> value;
         args->GetNext(&value);
         modifiers = GetKeyModifiersFromV8(args->isolate(), value);
         if (!args->PeekNext().IsEmpty()) {
           args->GetNext(send_gestures);
           if (!args->PeekNext().IsEmpty()) {
             v8::Local<v8::Value> phase_value;
             args->GetNext(&phase_value);
             phase = GetMouseWheelEventPhaseFromV8(phase_value);
           }
         }
       }
     }
   }
 
-  InitMouseEvent(WebInputEvent::MouseWheel,
-                 current_pointer_state_[kRawMousePointerId].pressed_button_,
+  current_pointer_state_[kRawMousePointerId].modifiers_ = modifiers;
+  WebMouseWheelEvent event(WebInputEvent::MouseWheel,
+                           ModifiersForPointer(kRawMousePointerId),
+                           GetCurrentEventTimeSec());
+  InitMouseEvent(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->phase = phase;
+                 click_count_, &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.phase = phase;
   if (scroll_type == MouseScrollType::PIXEL) {
-    event->wheelTicksX /= kScrollbarPixelsPerTick;
-    event->wheelTicksY /= kScrollbarPixelsPerTick;
+    event.wheelTicksX /= kScrollbarPixelsPerTick;
+    event.wheelTicksY /= kScrollbarPixelsPerTick;
   } else {
-    event->deltaX *= kScrollbarPixelsPerTick;
-    event->deltaY *= kScrollbarPixelsPerTick;
+    event.deltaX *= kScrollbarPixelsPerTick;
+    event.deltaY *= kScrollbarPixelsPerTick;
   }
+  return event;
 }
 
 // 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,
                                         WebPointerProperties* e,
                                         float* radius_x_pointer,
                                         float* radius_y_pointer) {
   if (!args->PeekNext().IsEmpty()) {
@@ skipping 111 matching lines @@
 }
 
 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;
+        current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers;
+        WebMouseEvent event(WebInputEvent::MouseMove,
+                            ModifiersForPointer(kRawMousePointerId),
+                            GetCurrentEventTimeSec());
         InitMouseEvent(
-            WebInputEvent::MouseMove,
             current_pointer_state_[kRawMousePointerId].pressed_button_,
             current_pointer_state_[kRawMousePointerId].current_buttons_, e.pos,
-            GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
+            click_count_, &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_[kRawMousePointerId].current_buttons_ &=
             ~GetWebMouseEventModifierForButton(e.button_type);
         current_pointer_state_[kRawMousePointerId].pressed_button_ =
             WebMouseEvent::Button::NoButton;
+        current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers;
 
-        WebMouseEvent event;
+        WebMouseEvent event(WebInputEvent::MouseUp,
+                            ModifiersForPointer(kRawMousePointerId),
+                            GetCurrentEventTimeSec());
         InitMouseEvent(
-            WebInputEvent::MouseUp, e.button_type,
+            e.button_type,
             current_pointer_state_[kRawMousePointerId].current_buttons_,
-            current_pointer_state_[kRawMousePointerId].last_pos_,
-            GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
+            current_pointer_state_[kRawMousePointerId].last_pos_, click_count_,
+            &event);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseUp(event);
         break;
       }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
@@ skipping 17 matching lines @@
   std::unique_ptr<WebInputEvent> widget_event =
       TransformScreenToWidgetCoordinates(raw_event);
   const WebInputEvent* event =
       widget_event.get() ? static_cast<WebMouseEvent*>(widget_event.get())
                          : &raw_event;
   return widget()->handleInputEvent(*event);
 }
 
 void EventSender::SendGesturesForMouseWheelEvent(
     const WebMouseWheelEvent wheel_event) {
-  WebGestureEvent begin_event;
-  InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollBegin,
-                                 GetCurrentEventTimeSec(), wheel_event,
-                                 &begin_event);
+  WebGestureEvent begin_event(WebInputEvent::GestureScrollBegin,
+                              wheel_event.modifiers, GetCurrentEventTimeSec());
+  InitGestureEventFromMouseWheel(wheel_event, &begin_event);
   begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX;
   begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY;
   if (wheel_event.scrollByPage) {
     begin_event.data.scrollBegin.deltaHintUnits = blink::WebGestureEvent::Page;
     if (begin_event.data.scrollBegin.deltaXHint) {
       begin_event.data.scrollBegin.deltaXHint =
           begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
     }
     if (begin_event.data.scrollBegin.deltaYHint) {
       begin_event.data.scrollBegin.deltaYHint =
           begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1;
     }
   } else {
     begin_event.data.scrollBegin.deltaHintUnits =
         wheel_event.hasPreciseScrollingDeltas
             ? blink::WebGestureEvent::PrecisePixels
             : blink::WebGestureEvent::Pixels;
   }
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(begin_event);
 
-  WebGestureEvent update_event;
-  InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollUpdate,
-                                 GetCurrentEventTimeSec(), wheel_event,
-                                 &update_event);
+  WebGestureEvent update_event(WebInputEvent::GestureScrollUpdate,
+                               wheel_event.modifiers, GetCurrentEventTimeSec());
+  InitGestureEventFromMouseWheel(wheel_event, &update_event);
   update_event.data.scrollUpdate.deltaX =
       begin_event.data.scrollBegin.deltaXHint;
   update_event.data.scrollUpdate.deltaY =
       begin_event.data.scrollBegin.deltaYHint;
   update_event.data.scrollUpdate.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(update_event);
 
-  WebGestureEvent end_event;
-  InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollEnd,
-                                 GetCurrentEventTimeSec(), wheel_event,
-                                 &end_event);
+  WebGestureEvent end_event(WebInputEvent::GestureScrollEnd,
+                            wheel_event.modifiers, GetCurrentEventTimeSec());
+  InitGestureEventFromMouseWheel(wheel_event, &end_event);
   end_event.data.scrollEnd.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     widget()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(end_event);
 }
 
 TestInterfaces* EventSender::interfaces() {
   return web_widget_test_proxy_base_->web_view_test_proxy_base()
@@ skipping 20 matching lines @@
   return view()->mainFrame()->toWebLocalFrame()->frameWidget();
 }
 
 std::unique_ptr<WebInputEvent> EventSender::TransformScreenToWidgetCoordinates(
     const WebInputEvent& event) {
   return delegate()->TransformScreenToWidgetCoordinates(
       web_widget_test_proxy_base_, event);
 }
 
 }  // namespace test_runner