Move //components/test_runner back into //content/shell

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>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build/build_config.h"
-#include "components/test_runner/mock_spell_check.h"
-#include "components/test_runner/test_interfaces.h"
-#include "components/test_runner/web_test_delegate.h"
-#include "components/test_runner/web_view_test_proxy.h"
-#include "components/test_runner/web_widget_test_proxy.h"
-#include "gin/handle.h"
-#include "gin/object_template_builder.h"
-#include "gin/wrappable.h"
-#include "net/base/filename_util.h"
-#include "third_party/WebKit/public/platform/URLConversion.h"
-#include "third_party/WebKit/public/platform/WebCoalescedInputEvent.h"
-#include "third_party/WebKit/public/platform/WebGestureEvent.h"
-#include "third_party/WebKit/public/platform/WebKeyboardEvent.h"
-#include "third_party/WebKit/public/platform/WebPointerProperties.h"
-#include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/platform/WebTouchEvent.h"
-#include "third_party/WebKit/public/platform/WebVector.h"
-#include "third_party/WebKit/public/web/WebContextMenuData.h"
-#include "third_party/WebKit/public/web/WebFrameWidget.h"
-#include "third_party/WebKit/public/web/WebKit.h"
-#include "third_party/WebKit/public/web/WebLocalFrame.h"
-#include "third_party/WebKit/public/web/WebPagePopup.h"
-#include "third_party/WebKit/public/web/WebView.h"
-#include "ui/events/blink/blink_event_util.h"
-#include "ui/events/keycodes/dom/keycode_converter.h"
-#include "ui/events/keycodes/keyboard_codes.h"
-#include "v8/include/v8.h"
-
-using blink::WebContextMenuData;
-using blink::WebDragData;
-using blink::WebDragOperationsMask;
-using blink::WebFloatPoint;
-using blink::WebGestureEvent;
-using blink::WebInputEvent;
-using blink::WebInputEventResult;
-using blink::WebKeyboardEvent;
-using blink::WebLocalFrame;
-using blink::WebMenuItemInfo;
-using blink::WebMouseEvent;
-using blink::WebMouseWheelEvent;
-using blink::WebPagePopup;
-using blink::WebPoint;
-using blink::WebPointerProperties;
-using blink::WebString;
-using blink::WebTouchEvent;
-using blink::WebTouchPoint;
-using blink::WebURL;
-using blink::WebVector;
-using blink::WebView;
-
-namespace test_runner {
-
-namespace {
-
-const int kRawMousePointerId = -1;
-const char* const kPointerTypeStringUnknown = "";
-const char* const kPointerTypeStringMouse = "mouse";
-const char* const kPointerTypeStringTouch = "touch";
-const char* const kPointerTypeStringPen = "pen";
-const char* const kPointerTypeStringEraser = "eraser";
-
-// Assigns |pointerType| from the provided |args|. Returns false if there was
-// any error.
-bool getPointerType(gin::Arguments* args,
-                    bool isOnlyMouseAndPenAllowed,
-                    WebPointerProperties::PointerType& pointerType) {
-  if (args->PeekNext().IsEmpty())
-    return true;
-  std::string pointer_type_string;
-  if (!args->GetNext(&pointer_type_string)) {
-    args->ThrowError();
-    return false;
-  }
-  if (isOnlyMouseAndPenAllowed &&
-      (pointer_type_string == kPointerTypeStringUnknown ||
-       pointer_type_string == kPointerTypeStringTouch)) {
-    args->ThrowError();
-    return false;
-  }
-  if (pointer_type_string == kPointerTypeStringUnknown) {
-    pointerType = WebMouseEvent::PointerType::Unknown;
-  } else if (pointer_type_string == kPointerTypeStringMouse) {
-    pointerType = WebMouseEvent::PointerType::Mouse;
-  } else if (pointer_type_string == kPointerTypeStringTouch) {
-    pointerType = WebMouseEvent::PointerType::Touch;
-  } else if (pointer_type_string == kPointerTypeStringPen) {
-    pointerType = WebMouseEvent::PointerType::Pen;
-  } else if (pointer_type_string == kPointerTypeStringEraser) {
-    pointerType = WebMouseEvent::PointerType::Eraser;
-  } else {
-    args->ThrowError();
-    return false;
-  }
-  return true;
-}
-
-// Parses |pointerType|, |rawPointerId|, |pressure|, |tiltX| and |tiltY| from
-// the provided |args|. Returns false if there was any error, assuming the last
-// 3 of the five parsed parameters are optional.
-bool getMousePenPointerProperties(
-    gin::Arguments* args,
-    WebPointerProperties::PointerType& pointerType,
-    int& rawPointerId,
-    float& pressure,
-    int& tiltX,
-    int& tiltY) {
-  pointerType = WebPointerProperties::PointerType::Mouse;
-  rawPointerId = kRawMousePointerId;
-  pressure = std::numeric_limits<float>::quiet_NaN();
-  tiltX = 0;
-  tiltY = 0;
-
-  // Only allow pen or mouse through this API.
-  if (!getPointerType(args, false, pointerType))
-    return false;
-  if (!args->PeekNext().IsEmpty()) {
-    if (!args->GetNext(&rawPointerId)) {
-      args->ThrowError();
-      return false;
-    }
-
-    // Parse optional params
-    if (!args->PeekNext().IsEmpty()) {
-      if (!args->GetNext(&pressure)) {
-        args->ThrowError();
-        return false;
-      }
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&tiltX)) {
-          args->ThrowError();
-          return false;
-        }
-        if (!args->PeekNext().IsEmpty()) {
-          if (!args->GetNext(&tiltY)) {
-            args->ThrowError();
-            return false;
-          }
-        }
-      }
-    }
-  }
-
-  return true;
-}
-
-WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) {
-  switch (button_code) {
-    case -1:
-      return WebMouseEvent::Button::NoButton;
-    case 0:
-      return WebMouseEvent::Button::Left;
-    case 1:
-      return WebMouseEvent::Button::Middle;
-    case 2:
-      return WebMouseEvent::Button::Right;
-  }
-  NOTREACHED();
-  return WebMouseEvent::Button::NoButton;
-}
-
-int GetWebMouseEventModifierForButton(WebMouseEvent::Button button) {
-  switch (button) {
-    case WebMouseEvent::Button::NoButton:
-      return 0;
-    case WebMouseEvent::Button::Left:
-      return WebMouseEvent::LeftButtonDown;
-    case WebMouseEvent::Button::Middle:
-      return WebMouseEvent::MiddleButtonDown;
-    case WebMouseEvent::Button::Right:
-      return WebMouseEvent::RightButtonDown;
-    case WebPointerProperties::Button::X1:
-    case WebPointerProperties::Button::X2:
-    case WebPointerProperties::Button::Eraser:
-      return 0; // Not implemented yet
-  }
-  NOTREACHED();
-  return 0;
-}
-
-const int kButtonsInModifiers = WebMouseEvent::LeftButtonDown
-    | WebMouseEvent::MiddleButtonDown | WebMouseEvent::RightButtonDown;
-
-int modifiersWithButtons(int modifiers, int buttons) {
-  return (modifiers & ~kButtonsInModifiers)
-      | (buttons & kButtonsInModifiers);
-}
-
-void InitMouseEventGeneric(WebMouseEvent::Button b,
-                           int current_buttons,
-                           const WebPoint& pos,
-                           int click_count,
-                           WebPointerProperties::PointerType pointerType,
-                           int pointerId,
-                           float pressure,
-                           int tiltX,
-                           int tiltY,
-                           WebMouseEvent* e) {
-  e->button = b;
-  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->clickCount = click_count;
-}
-
-void InitMouseEvent(WebMouseEvent::Button b,
-                    int current_buttons,
-                    const WebPoint& pos,
-                    int click_count,
-                    WebMouseEvent* e) {
-  InitMouseEventGeneric(b, current_buttons, pos, click_count,
-                        WebPointerProperties::PointerType::Mouse, 0, 0.0, 0, 0,
-                        e);
-}
-
-void InitGestureEventFromMouseWheel(const WebMouseWheelEvent& wheel_event,
-                                    WebGestureEvent* gesture_event) {
-  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;
-}
-
-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;
-  } else if (!strcmp(characters, "shiftKey") ||
-             !strcmp(characters, "rangeSelectionKey")) {
-    return WebInputEvent::ShiftKey;
-  } else if (!strcmp(characters, "altKey")) {
-    return WebInputEvent::AltKey;
-#ifdef __APPLE__
-  } else if (!strcmp(characters, "metaKey") ||
-             !strcmp(characters, "addSelectionKey")) {
-    return WebInputEvent::MetaKey;
-#else
-  } else if (!strcmp(characters, "metaKey")) {
-    return WebInputEvent::MetaKey;
-#endif
-  } else if (!strcmp(characters, "autoRepeat")) {
-    return WebInputEvent::IsAutoRepeat;
-  } else if (!strcmp(characters, "copyKey")) {
-#ifdef __APPLE__
-    return WebInputEvent::AltKey;
-#else
-    return WebInputEvent::ControlKey;
-#endif
-  } else if (!strcmp(characters, "accessKey")) {
-#ifdef __APPLE__
-    return WebInputEvent::AltKey | WebInputEvent::ControlKey;
-#else
-    return WebInputEvent::AltKey;
-#endif
-  } else if (!strcmp(characters, "leftButton")) {
-    return WebInputEvent::LeftButtonDown;
-  } else if (!strcmp(characters, "middleButton")) {
-    return WebInputEvent::MiddleButtonDown;
-  } else if (!strcmp(characters, "rightButton")) {
-    return WebInputEvent::RightButtonDown;
-  } else if (!strcmp(characters, "capsLockOn")) {
-    return WebInputEvent::CapsLockOn;
-  } else if (!strcmp(characters, "numLockOn")) {
-    return WebInputEvent::NumLockOn;
-  } else if (!strcmp(characters, "locationLeft")) {
-    return WebInputEvent::IsLeft;
-  } else if (!strcmp(characters, "locationRight")) {
-    return WebInputEvent::IsRight;
-  } else if (!strcmp(characters, "locationNumpad")) {
-    return WebInputEvent::IsKeyPad;
-  } else if (!strcmp(characters, "isComposing")) {
-    return WebInputEvent::IsComposing;
-  } else if (!strcmp(characters, "altGraphKey")) {
-    return WebInputEvent::AltGrKey;
-  } else if (!strcmp(characters, "fnKey")) {
-    return WebInputEvent::FnKey;
-  } else if (!strcmp(characters, "symbolKey")) {
-    return WebInputEvent::SymbolKey;
-  } else if (!strcmp(characters, "scrollLockOn")) {
-    return WebInputEvent::ScrollLockOn;
-  }
-
-  return 0;
-}
-
-int GetKeyModifiers(const std::vector<std::string>& modifier_names) {
-  int modifiers = 0;
-  for (std::vector<std::string>::const_iterator it = modifier_names.begin();
-       it != modifier_names.end(); ++it) {
-    modifiers |= GetKeyModifier(*it);
-  }
-  return modifiers;
-}
-
-int GetKeyModifiersFromV8(v8::Isolate* isolate, v8::Local<v8::Value> value) {
-  std::vector<std::string> modifier_names;
-  if (value->IsString()) {
-    modifier_names.push_back(gin::V8ToString(value));
-  } else if (value->IsArray()) {
-    gin::Converter<std::vector<std::string> >::FromV8(
-        isolate, value, &modifier_names);
-  }
-  return GetKeyModifiers(modifier_names);
-}
-
-WebMouseWheelEvent::Phase GetMouseWheelEventPhase(
-    const std::string& phase_name) {
-  if (phase_name == "phaseNone") {
-    return WebMouseWheelEvent::PhaseNone;
-  } else if (phase_name == "phaseBegan") {
-    return WebMouseWheelEvent::PhaseBegan;
-  } else if (phase_name == "phaseStationary") {
-    return WebMouseWheelEvent::PhaseStationary;
-  } else if (phase_name == "phaseChanged") {
-    return WebMouseWheelEvent::PhaseChanged;
-  } else if (phase_name == "phaseEnded") {
-    return WebMouseWheelEvent::PhaseEnded;
-  } else if (phase_name == "phaseCancelled") {
-    return WebMouseWheelEvent::PhaseCancelled;
-  } else if (phase_name == "phaseMayBegin") {
-    return WebMouseWheelEvent::PhaseMayBegin;
-  }
-
-  return WebMouseWheelEvent::PhaseNone;
-}
-
-WebMouseWheelEvent::Phase GetMouseWheelEventPhaseFromV8(
-    v8::Local<v8::Value> value) {
-  if (value->IsString())
-    return GetMouseWheelEventPhase(gin::V8ToString(value));
-  return WebMouseWheelEvent::PhaseNone;
-}
-
-// Maximum distance (in space and time) for a mouse click to register as a
-// double or triple click.
-const double kMultipleClickTimeSec = 1;
-const int kMultipleClickRadiusPixels = 5;
-const char kSubMenuDepthIdentifier[] = "_";
-const char kSubMenuIdentifier[] = " >";
-const char kSeparatorIdentifier[] = "---------";
-const char kDisabledIdentifier[] = "#";
-const char kCheckedIdentifier[] = "*";
-
-bool OutsideMultiClickRadius(const WebPoint& a, const WebPoint& b) {
-  return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) >
-         kMultipleClickRadiusPixels * kMultipleClickRadiusPixels;
-}
-
-void PopulateCustomItems(const WebVector<WebMenuItemInfo>& customItems,
-    const std::string& prefix, std::vector<std::string>* strings) {
-  for (size_t i = 0; i < customItems.size(); ++i) {
-    std::string prefixCopy = prefix;
-    if (!customItems[i].enabled)
-        prefixCopy = kDisabledIdentifier + prefix;
-    if (customItems[i].checked)
-        prefixCopy = kCheckedIdentifier + prefix;
-    if (customItems[i].type == blink::WebMenuItemInfo::Separator) {
-      strings->push_back(prefixCopy + kSeparatorIdentifier);
-    } else if (customItems[i].type == blink::WebMenuItemInfo::SubMenu) {
-      strings->push_back(prefixCopy + customItems[i].label.utf8() +
-          customItems[i].icon.utf8() + kSubMenuIdentifier);
-      PopulateCustomItems(customItems[i].subMenuItems, prefixCopy +
-          kSubMenuDepthIdentifier, strings);
-    } else {
-      strings->push_back(prefixCopy + customItems[i].label.utf8() +
-          customItems[i].icon.utf8());
-    }
-  }
-}
-
-// Because actual context menu is implemented by the browser side,
-// this function does only what LayoutTests are expecting:
-// - Many test checks the count of items. So returning non-zero value makes
-// sense.
-// - Some test compares the count before and after some action. So changing the
-// count based on flags also makes sense. This function is doing such for some
-// flags.
-// - Some test even checks actual string content. So providing it would be also
-// helpful.
-std::vector<std::string> MakeMenuItemStringsFor(
-    WebContextMenuData* context_menu,
-    WebTestDelegate* delegate) {
-  // These constants are based on Safari's context menu because tests are made
-  // for it.
-  static const char* kNonEditableMenuStrings[] = {
-    "Back",
-    "Reload Page",
-    "Open in Dashbaord",
-    "<separator>",
-    "View Source",
-    "Save Page As",
-    "Print Page",
-    "Inspect Element",
-    0
-  };
-  static const char* kEditableMenuStrings[] = {
-    "Cut",
-    "Copy",
-    "<separator>",
-    "Paste",
-    "Spelling and Grammar",
-    "Substitutions, Transformations",
-    "Font",
-    "Speech",
-    "Paragraph Direction",
-    "<separator>",
-    0
-  };
-
-  // This is possible because mouse events are cancelleable.
-  if (!context_menu)
-    return std::vector<std::string>();
-
-  std::vector<std::string> strings;
-
-  // Populate custom menu items if provided by blink.
-  PopulateCustomItems(context_menu->customItems, "", &strings);
-
-  if (context_menu->isEditable) {
-    for (const char** item = kEditableMenuStrings; *item; ++item) {
-      strings.push_back(*item);
-    }
-    WebVector<WebString> suggestions;
-    MockSpellCheck::FillSuggestionList(context_menu->misspelledWord,
-                                       &suggestions);
-    for (size_t i = 0; i < suggestions.size(); ++i) {
-      strings.push_back(suggestions[i].utf8());
-    }
-  } else {
-    for (const char** item = kNonEditableMenuStrings; *item; ++item) {
-      strings.push_back(*item);
-    }
-  }
-
-  return strings;
-}
-
-// How much we should scroll per event - the value here is chosen to match the
-// WebKit impl and layout test results.
-const float kScrollbarPixelsPerTick = 40.0f;
-
-// Get the edit command corresponding to a keyboard event.
-// Returns true if the specified event corresponds to an edit command, the name
-// of the edit command will be stored in |*name|.
-bool GetEditCommand(const WebKeyboardEvent& event, std::string* name) {
-#if defined(OS_MACOSX)
-// We only cares about Left,Right,Up,Down keys with Command or Command+Shift
-// modifiers. These key events correspond to some special movement and
-// selection editor commands. These keys will be marked as system key, which
-// prevents them from being handled. Thus they must be handled specially.
-  if ((event.modifiers() & ~WebKeyboardEvent::ShiftKey) !=
-      WebKeyboardEvent::MetaKey)
-    return false;
-
-  switch (event.windowsKeyCode) {
-    case ui::VKEY_LEFT:
-      *name = "MoveToBeginningOfLine";
-      break;
-    case ui::VKEY_RIGHT:
-      *name = "MoveToEndOfLine";
-      break;
-    case ui::VKEY_UP:
-      *name = "MoveToBeginningOfDocument";
-      break;
-    case ui::VKEY_DOWN:
-      *name = "MoveToEndOfDocument";
-      break;
-    default:
-      return false;
-  }
-
-  if (event.modifiers() & WebKeyboardEvent::ShiftKey)
-    name->append("AndModifySelection");
-
-  return true;
-#else
-  return false;
-#endif
-}
-
-bool IsSystemKeyEvent(const WebKeyboardEvent& event) {
-#if defined(OS_MACOSX)
-  return event.modifiers() & WebInputEvent::MetaKey &&
-         event.windowsKeyCode != ui::VKEY_B &&
-         event.windowsKeyCode != ui::VKEY_I;
-#else
-  return !!(event.modifiers() & WebInputEvent::AltKey);
-#endif
-}
-
-bool GetScrollUnits(gin::Arguments* args, WebGestureEvent::ScrollUnits* units) {
-  std::string units_string;
-  if (!args->PeekNext().IsEmpty()) {
-    if (args->PeekNext()->IsString())
-      args->GetNext(&units_string);
-    if (units_string == "Page") {
-      *units = WebGestureEvent::Page;
-      return true;
-    } else if (units_string == "Pixels") {
-      *units = WebGestureEvent::Pixels;
-      return true;
-    } else if (units_string == "PrecisePixels") {
-      *units = WebGestureEvent::PrecisePixels;
-      return true;
-    } else {
-      args->ThrowError();
-      return false;
-    }
-  } else {
-    *units = WebGestureEvent::PrecisePixels;
-    return true;
-  }
-}
-
-const char* kSourceDeviceStringTouchpad = "touchpad";
-const char* kSourceDeviceStringTouchscreen = "touchscreen";
-
-}  // namespace
-
-class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
- public:
-  static gin::WrapperInfo kWrapperInfo;
-
-  static void Install(base::WeakPtr<EventSender> sender,
-                      blink::WebLocalFrame* frame);
-
- private:
-  explicit EventSenderBindings(base::WeakPtr<EventSender> sender);
-  ~EventSenderBindings() override;
-
-  // gin::Wrappable:
-  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) override;
-
-  // Bound methods:
-  void EnableDOMUIEventLogging();
-  void FireKeyboardEventsToElement();
-  void ClearKillRing();
-  std::vector<std::string> ContextClick();
-  void TextZoomIn();
-  void TextZoomOut();
-  void ZoomPageIn();
-  void ZoomPageOut();
-  void SetPageZoomFactor(double factor);
-  void ClearTouchPoints();
-  void ReleaseTouchPoint(unsigned index);
-  void UpdateTouchPoint(unsigned index,
-                        double x,
-                        double y,
-                        gin::Arguments* args);
-  void CancelTouchPoint(unsigned index);
-  void SetTouchModifier(const std::string& key_name, bool set_mask);
-  void SetTouchCancelable(bool cancelable);
-  void DumpFilenameBeingDragged();
-  void GestureFlingCancel();
-  void GestureFlingStart(float x,
-                         float y,
-                         float velocity_x,
-                         float velocity_y,
-                         gin::Arguments* args);
-  bool IsFlinging() const;
-  void GestureScrollFirstPoint(int x, int y);
-  void TouchStart(gin::Arguments* args);
-  void TouchMove(gin::Arguments* args);
-  void TouchCancel(gin::Arguments* args);
-  void TouchEnd(gin::Arguments* args);
-  void NotifyStartOfTouchScroll();
-  void LeapForward(int milliseconds);
-  double LastEventTimestamp();
-  void BeginDragWithFiles(const std::vector<std::string>& files);
-  void AddTouchPoint(double x, double y, gin::Arguments* args);
-  void GestureScrollBegin(gin::Arguments* args);
-  void GestureScrollEnd(gin::Arguments* args);
-  void GestureScrollUpdate(gin::Arguments* args);
-  void GesturePinchBegin(gin::Arguments* args);
-  void GesturePinchEnd(gin::Arguments* args);
-  void GesturePinchUpdate(gin::Arguments* args);
-  void GestureTap(gin::Arguments* args);
-  void GestureTapDown(gin::Arguments* args);
-  void GestureShowPress(gin::Arguments* args);
-  void GestureTapCancel(gin::Arguments* args);
-  void GestureLongPress(gin::Arguments* args);
-  void GestureLongTap(gin::Arguments* args);
-  void GestureTwoFingerTap(gin::Arguments* args);
-  void ContinuousMouseScrollBy(gin::Arguments* args);
-  void MouseMoveTo(gin::Arguments* args);
-  void MouseLeave();
-  void MouseScrollBy(gin::Arguments* args);
-  void ScheduleAsynchronousClick(gin::Arguments* args);
-  void ScheduleAsynchronousKeyDown(gin::Arguments* args);
-  void MouseDown(gin::Arguments* args);
-  void MouseUp(gin::Arguments* args);
-  void SetMouseButtonState(gin::Arguments* args);
-  void KeyDown(gin::Arguments* args);
-
-  // Binding properties:
-  bool ForceLayoutOnEvents() const;
-  void SetForceLayoutOnEvents(bool force);
-  bool IsDragMode() const;
-  void SetIsDragMode(bool drag_mode);
-
-#if defined(OS_WIN)
-  int WmKeyDown() const;
-  void SetWmKeyDown(int key_down);
-
-  int WmKeyUp() const;
-  void SetWmKeyUp(int key_up);
-
-  int WmChar() const;
-  void SetWmChar(int wm_char);
-
-  int WmDeadChar() const;
-  void SetWmDeadChar(int dead_char);
-
-  int WmSysKeyDown() const;
-  void SetWmSysKeyDown(int key_down);
-
-  int WmSysKeyUp() const;
-  void SetWmSysKeyUp(int key_up);
-
-  int WmSysChar() const;
-  void SetWmSysChar(int sys_char);
-
-  int WmSysDeadChar() const;
-  void SetWmSysDeadChar(int sys_dead_char);
-#endif
-
-  base::WeakPtr<EventSender> sender_;
-
-  DISALLOW_COPY_AND_ASSIGN(EventSenderBindings);
-};
-
-gin::WrapperInfo EventSenderBindings::kWrapperInfo = {gin::kEmbedderNativeGin};
-
-EventSenderBindings::EventSenderBindings(base::WeakPtr<EventSender> sender)
-    : sender_(sender) {
-}
-
-EventSenderBindings::~EventSenderBindings() {}
-
-// static
-void EventSenderBindings::Install(base::WeakPtr<EventSender> sender,
-                                  WebLocalFrame* frame) {
-  v8::Isolate* isolate = blink::mainThreadIsolate();
-  v8::HandleScope handle_scope(isolate);
-  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
-  if (context.IsEmpty())
-    return;
-
-  v8::Context::Scope context_scope(context);
-
-  gin::Handle<EventSenderBindings> bindings =
-      gin::CreateHandle(isolate, new EventSenderBindings(sender));
-  if (bindings.IsEmpty())
-    return;
-  v8::Local<v8::Object> global = context->Global();
-  global->Set(gin::StringToV8(isolate, "eventSender"), bindings.ToV8());
-}
-
-gin::ObjectTemplateBuilder
-EventSenderBindings::GetObjectTemplateBuilder(v8::Isolate* isolate) {
-  return gin::Wrappable<EventSenderBindings>::GetObjectTemplateBuilder(isolate)
-      .SetMethod("enableDOMUIEventLogging",
-                 &EventSenderBindings::EnableDOMUIEventLogging)
-      .SetMethod("fireKeyboardEventsToElement",
-                 &EventSenderBindings::FireKeyboardEventsToElement)
-      .SetMethod("clearKillRing", &EventSenderBindings::ClearKillRing)
-      .SetMethod("contextClick", &EventSenderBindings::ContextClick)
-      .SetMethod("textZoomIn", &EventSenderBindings::TextZoomIn)
-      .SetMethod("textZoomOut", &EventSenderBindings::TextZoomOut)
-      .SetMethod("zoomPageIn", &EventSenderBindings::ZoomPageIn)
-      .SetMethod("zoomPageOut", &EventSenderBindings::ZoomPageOut)
-      .SetMethod("setPageZoomFactor", &EventSenderBindings::SetPageZoomFactor)
-      .SetMethod("clearTouchPoints", &EventSenderBindings::ClearTouchPoints)
-      .SetMethod("releaseTouchPoint", &EventSenderBindings::ReleaseTouchPoint)
-      .SetMethod("updateTouchPoint", &EventSenderBindings::UpdateTouchPoint)
-      .SetMethod("cancelTouchPoint", &EventSenderBindings::CancelTouchPoint)
-      .SetMethod("setTouchModifier", &EventSenderBindings::SetTouchModifier)
-      .SetMethod("setTouchCancelable", &EventSenderBindings::SetTouchCancelable)
-      .SetMethod("dumpFilenameBeingDragged",
-                 &EventSenderBindings::DumpFilenameBeingDragged)
-      .SetMethod("gestureFlingCancel", &EventSenderBindings::GestureFlingCancel)
-      .SetMethod("gestureFlingStart", &EventSenderBindings::GestureFlingStart)
-      .SetMethod("isFlinging", &EventSenderBindings::IsFlinging)
-      .SetMethod("gestureScrollFirstPoint",
-                 &EventSenderBindings::GestureScrollFirstPoint)
-      .SetMethod("touchStart", &EventSenderBindings::TouchStart)
-      .SetMethod("touchMove", &EventSenderBindings::TouchMove)
-      .SetMethod("touchCancel", &EventSenderBindings::TouchCancel)
-      .SetMethod("touchEnd", &EventSenderBindings::TouchEnd)
-      .SetMethod("notifyStartOfTouchScroll",
-                 &EventSenderBindings::NotifyStartOfTouchScroll)
-      .SetMethod("leapForward", &EventSenderBindings::LeapForward)
-      .SetMethod("lastEventTimestamp", &EventSenderBindings::LastEventTimestamp)
-      .SetMethod("beginDragWithFiles", &EventSenderBindings::BeginDragWithFiles)
-      .SetMethod("addTouchPoint", &EventSenderBindings::AddTouchPoint)
-      .SetMethod("gestureScrollBegin", &EventSenderBindings::GestureScrollBegin)
-      .SetMethod("gestureScrollEnd", &EventSenderBindings::GestureScrollEnd)
-      .SetMethod("gestureScrollUpdate",
-                 &EventSenderBindings::GestureScrollUpdate)
-      .SetMethod("gesturePinchBegin", &EventSenderBindings::GesturePinchBegin)
-      .SetMethod("gesturePinchEnd", &EventSenderBindings::GesturePinchEnd)
-      .SetMethod("gesturePinchUpdate", &EventSenderBindings::GesturePinchUpdate)
-      .SetMethod("gestureTap", &EventSenderBindings::GestureTap)
-      .SetMethod("gestureTapDown", &EventSenderBindings::GestureTapDown)
-      .SetMethod("gestureShowPress", &EventSenderBindings::GestureShowPress)
-      .SetMethod("gestureTapCancel", &EventSenderBindings::GestureTapCancel)
-      .SetMethod("gestureLongPress", &EventSenderBindings::GestureLongPress)
-      .SetMethod("gestureLongTap", &EventSenderBindings::GestureLongTap)
-      .SetMethod("gestureTwoFingerTap",
-                 &EventSenderBindings::GestureTwoFingerTap)
-      .SetMethod("continuousMouseScrollBy",
-                 &EventSenderBindings::ContinuousMouseScrollBy)
-      .SetMethod("keyDown", &EventSenderBindings::KeyDown)
-      .SetMethod("mouseDown", &EventSenderBindings::MouseDown)
-      .SetMethod("mouseMoveTo", &EventSenderBindings::MouseMoveTo)
-      .SetMethod("mouseLeave", &EventSenderBindings::MouseLeave)
-      .SetMethod("mouseScrollBy", &EventSenderBindings::MouseScrollBy)
-      .SetMethod("mouseUp", &EventSenderBindings::MouseUp)
-      .SetMethod("setMouseButtonState",
-                 &EventSenderBindings::SetMouseButtonState)
-      .SetMethod("scheduleAsynchronousClick",
-                 &EventSenderBindings::ScheduleAsynchronousClick)
-      .SetMethod("scheduleAsynchronousKeyDown",
-                 &EventSenderBindings::ScheduleAsynchronousKeyDown)
-      .SetProperty("forceLayoutOnEvents",
-                   &EventSenderBindings::ForceLayoutOnEvents,
-                   &EventSenderBindings::SetForceLayoutOnEvents)
-#if defined(OS_WIN)
-      .SetProperty("WM_KEYDOWN", &EventSenderBindings::WmKeyDown,
-                   &EventSenderBindings::SetWmKeyDown)
-      .SetProperty("WM_KEYUP", &EventSenderBindings::WmKeyUp,
-                   &EventSenderBindings::SetWmKeyUp)
-      .SetProperty("WM_CHAR", &EventSenderBindings::WmChar,
-                   &EventSenderBindings::SetWmChar)
-      .SetProperty("WM_DEADCHAR", &EventSenderBindings::WmDeadChar,
-                   &EventSenderBindings::SetWmDeadChar)
-      .SetProperty("WM_SYSKEYDOWN", &EventSenderBindings::WmSysKeyDown,
-                   &EventSenderBindings::SetWmSysKeyDown)
-      .SetProperty("WM_SYSKEYUP", &EventSenderBindings::WmSysKeyUp,
-                   &EventSenderBindings::SetWmSysKeyUp)
-      .SetProperty("WM_SYSCHAR", &EventSenderBindings::WmSysChar,
-                   &EventSenderBindings::SetWmSysChar)
-      .SetProperty("WM_SYSDEADCHAR", &EventSenderBindings::WmSysDeadChar,
-                   &EventSenderBindings::SetWmSysDeadChar)
-#endif
-      .SetProperty("dragMode", &EventSenderBindings::IsDragMode,
-                   &EventSenderBindings::SetIsDragMode);
-}
-
-void EventSenderBindings::EnableDOMUIEventLogging() {
-  if (sender_)
-    sender_->EnableDOMUIEventLogging();
-}
-
-void EventSenderBindings::FireKeyboardEventsToElement() {
-  if (sender_)
-    sender_->FireKeyboardEventsToElement();
-}
-
-void EventSenderBindings::ClearKillRing() {
-  if (sender_)
-    sender_->ClearKillRing();
-}
-
-std::vector<std::string> EventSenderBindings::ContextClick() {
-  if (sender_)
-    return sender_->ContextClick();
-  return std::vector<std::string>();
-}
-
-void EventSenderBindings::TextZoomIn() {
-  if (sender_)
-    sender_->TextZoomIn();
-}
-
-void EventSenderBindings::TextZoomOut() {
-  if (sender_)
-    sender_->TextZoomOut();
-}
-
-void EventSenderBindings::ZoomPageIn() {
-  if (sender_)
-    sender_->ZoomPageIn();
-}
-
-void EventSenderBindings::ZoomPageOut() {
-  if (sender_)
-    sender_->ZoomPageOut();
-}
-
-void EventSenderBindings::SetPageZoomFactor(double factor) {
-  if (sender_)
-    sender_->SetPageZoomFactor(factor);
-}
-
-void EventSenderBindings::ClearTouchPoints() {
-  if (sender_)
-    sender_->ClearTouchPoints();
-}
-
-void EventSenderBindings::ReleaseTouchPoint(unsigned index) {
-  if (sender_)
-    sender_->ReleaseTouchPoint(index);
-}
-
-void EventSenderBindings::UpdateTouchPoint(unsigned index,
-                                           double x,
-                                           double y,
-                                           gin::Arguments* args) {
-  if (sender_) {
-    sender_->UpdateTouchPoint(index, static_cast<float>(x),
-                              static_cast<float>(y), args);
-  }
-}
-
-void EventSenderBindings::CancelTouchPoint(unsigned index) {
-  if (sender_)
-    sender_->CancelTouchPoint(index);
-}
-
-void EventSenderBindings::SetTouchModifier(const std::string& key_name,
-                                           bool set_mask) {
-  if (sender_)
-    sender_->SetTouchModifier(key_name, set_mask);
-}
-
-void EventSenderBindings::SetTouchCancelable(bool cancelable) {
-  if (sender_)
-    sender_->SetTouchCancelable(cancelable);
-}
-
-void EventSenderBindings::DumpFilenameBeingDragged() {
-  if (sender_)
-    sender_->DumpFilenameBeingDragged();
-}
-
-void EventSenderBindings::GestureFlingCancel() {
-  if (sender_)
-    sender_->GestureFlingCancel();
-}
-
-void EventSenderBindings::GestureFlingStart(float x,
-                                            float y,
-                                            float velocity_x,
-                                            float velocity_y,
-                                            gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureFlingStart(x, y, velocity_x, velocity_y, args);
-}
-
-bool EventSenderBindings::IsFlinging() const {
-  if (sender_)
-    return sender_->IsFlinging();
-  return false;
-}
-
-void EventSenderBindings::GestureScrollFirstPoint(int x, int y) {
-  if (sender_)
-    sender_->GestureScrollFirstPoint(x, y);
-}
-
-void EventSenderBindings::TouchStart(gin::Arguments* args) {
-  if (sender_)
-    sender_->TouchStart(args);
-}
-
-void EventSenderBindings::TouchMove(gin::Arguments* args) {
-  if (sender_)
-    sender_->TouchMove(args);
-}
-
-void EventSenderBindings::TouchCancel(gin::Arguments* args) {
-  if (sender_)
-    sender_->TouchCancel(args);
-}
-
-void EventSenderBindings::TouchEnd(gin::Arguments* args) {
-  if (sender_)
-    sender_->TouchEnd(args);
-}
-
-void EventSenderBindings::NotifyStartOfTouchScroll() {
-  if (sender_)
-    sender_->NotifyStartOfTouchScroll();
-}
-
-void EventSenderBindings::LeapForward(int milliseconds) {
-  if (sender_)
-    sender_->LeapForward(milliseconds);
-}
-
-double EventSenderBindings::LastEventTimestamp() {
-  if (sender_)
-    return sender_->last_event_timestamp();
-  return 0;
-}
-
-void EventSenderBindings::BeginDragWithFiles(
-    const std::vector<std::string>& files) {
-  if (sender_)
-    sender_->BeginDragWithFiles(files);
-}
-
-void EventSenderBindings::AddTouchPoint(double x,
-                                        double y,
-                                        gin::Arguments* args) {
-  if (sender_)
-    sender_->AddTouchPoint(static_cast<float>(x), static_cast<float>(y), args);
-}
-
-void EventSenderBindings::GestureScrollBegin(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureScrollBegin(args);
-}
-
-void EventSenderBindings::GestureScrollEnd(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureScrollEnd(args);
-}
-
-void EventSenderBindings::GestureScrollUpdate(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureScrollUpdate(args);
-}
-
-void EventSenderBindings::GesturePinchBegin(gin::Arguments* args) {
-  if (sender_)
-    sender_->GesturePinchBegin(args);
-}
-
-void EventSenderBindings::GesturePinchEnd(gin::Arguments* args) {
-  if (sender_)
-    sender_->GesturePinchEnd(args);
-}
-
-void EventSenderBindings::GesturePinchUpdate(gin::Arguments* args) {
-  if (sender_)
-    sender_->GesturePinchUpdate(args);
-}
-
-void EventSenderBindings::GestureTap(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureTap(args);
-}
-
-void EventSenderBindings::GestureTapDown(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureTapDown(args);
-}
-
-void EventSenderBindings::GestureShowPress(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureShowPress(args);
-}
-
-void EventSenderBindings::GestureTapCancel(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureTapCancel(args);
-}
-
-void EventSenderBindings::GestureLongPress(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureLongPress(args);
-}
-
-void EventSenderBindings::GestureLongTap(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureLongTap(args);
-}
-
-void EventSenderBindings::GestureTwoFingerTap(gin::Arguments* args) {
-  if (sender_)
-    sender_->GestureTwoFingerTap(args);
-}
-
-void EventSenderBindings::ContinuousMouseScrollBy(gin::Arguments* args) {
-  if (sender_)
-    sender_->MouseScrollBy(args, EventSender::MouseScrollType::PIXEL);
-}
-
-void EventSenderBindings::MouseMoveTo(gin::Arguments* args) {
-  if (sender_)
-    sender_->MouseMoveTo(args);
-}
-
-void EventSenderBindings::MouseLeave() {
-  if (sender_)
-    sender_->MouseLeave();
-}
-
-void EventSenderBindings::MouseScrollBy(gin::Arguments* args) {
-  if (sender_)
-    sender_->MouseScrollBy(args, EventSender::MouseScrollType::TICK);
-}
-
-void EventSenderBindings::ScheduleAsynchronousClick(gin::Arguments* args) {
-  if (!sender_)
-    return;
-
-  int button_number = 0;
-  int modifiers = 0;
-  if (!args->PeekNext().IsEmpty()) {
-    args->GetNext(&button_number);
-    if (!args->PeekNext().IsEmpty())
-      modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
-  }
-  sender_->ScheduleAsynchronousClick(button_number, modifiers);
-}
-
-void EventSenderBindings::ScheduleAsynchronousKeyDown(gin::Arguments* args) {
-  if (!sender_)
-    return;
-
-  std::string code_str;
-  int modifiers = 0;
-  int location = DOMKeyLocationStandard;
-  args->GetNext(&code_str);
-  if (!args->PeekNext().IsEmpty()) {
-    v8::Local<v8::Value> value;
-    args->GetNext(&value);
-    modifiers = GetKeyModifiersFromV8(args->isolate(), value);
-    if (!args->PeekNext().IsEmpty())
-      args->GetNext(&location);
-  }
-  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;
-  if (!args->PeekNext().IsEmpty()) {
-    if (!args->GetNext(&button_number)) {
-      args->ThrowError();
-      return;
-    }
-    if (!args->PeekNext().IsEmpty()) {
-      modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
-      args->Skip();
-    }
-  }
-
-  WebPointerProperties::PointerType pointerType =
-      WebPointerProperties::PointerType::Mouse;
-  int pointerId = 0;
-  float pressure = 0;
-  int tiltX = 0;
-  int tiltY = 0;
-  if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
-                                    tiltX, tiltY))
-    return;
-
-  sender_->PointerDown(button_number, modifiers, pointerType, pointerId,
-                       pressure, tiltX, tiltY);
-}
-
-void EventSenderBindings::MouseUp(gin::Arguments* args) {
-  if (!sender_)
-    return;
-
-  int button_number = 0;
-  int modifiers = 0;
-  if (!args->PeekNext().IsEmpty()) {
-    if (!args->GetNext(&button_number)) {
-      args->ThrowError();
-      return;
-    }
-    if (!args->PeekNext().IsEmpty()) {
-      modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
-      args->Skip();
-    }
-  }
-
-  WebPointerProperties::PointerType pointerType =
-      WebPointerProperties::PointerType::Mouse;
-  int pointerId = 0;
-  float pressure = 0;
-  int tiltX = 0;
-  int tiltY = 0;
-  if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
-                                    tiltX, tiltY))
-    return;
-
-  sender_->PointerUp(button_number, modifiers, pointerType, pointerId, pressure,
-                     tiltX, tiltY);
-}
-
-void EventSenderBindings::SetMouseButtonState(gin::Arguments* args) {
-  if (!sender_)
-    return;
-
-  int button_number;
-  if (!args->GetNext(&button_number)) {
-    args->ThrowError();
-    return;
-  }
-
-  int modifiers = -1;  // Default to the modifier implied by button_number
-  if (!args->PeekNext().IsEmpty()) {
-    modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
-  }
-
-  sender_->SetMouseButtonState(button_number, modifiers);
-}
-
-void EventSenderBindings::KeyDown(gin::Arguments* args) {
-  if (!sender_)
-    return;
-
-  std::string code_str;
-  int modifiers = 0;
-  int location = DOMKeyLocationStandard;
-  args->GetNext(&code_str);
-  if (!args->PeekNext().IsEmpty()) {
-    v8::Local<v8::Value> value;
-    args->GetNext(&value);
-    modifiers = GetKeyModifiersFromV8(args->isolate(), value);
-    if (!args->PeekNext().IsEmpty())
-      args->GetNext(&location);
-  }
-  sender_->KeyDown(code_str, modifiers, static_cast<KeyLocationCode>(location));
-}
-
-bool EventSenderBindings::ForceLayoutOnEvents() const {
-  if (sender_)
-    return sender_->force_layout_on_events();
-  return false;
-}
-
-void EventSenderBindings::SetForceLayoutOnEvents(bool force) {
-  if (sender_)
-    sender_->set_force_layout_on_events(force);
-}
-
-bool EventSenderBindings::IsDragMode() const {
-  if (sender_)
-    return sender_->is_drag_mode();
-  return true;
-}
-
-void EventSenderBindings::SetIsDragMode(bool drag_mode) {
-  if (sender_)
-    sender_->set_is_drag_mode(drag_mode);
-}
-
-#if defined(OS_WIN)
-int EventSenderBindings::WmKeyDown() const {
-  if (sender_)
-    return sender_->wm_key_down();
-  return 0;
-}
-
-void EventSenderBindings::SetWmKeyDown(int key_down) {
-  if (sender_)
-    sender_->set_wm_key_down(key_down);
-}
-
-int EventSenderBindings::WmKeyUp() const {
-  if (sender_)
-    return sender_->wm_key_up();
-  return 0;
-}
-
-void EventSenderBindings::SetWmKeyUp(int key_up) {
-  if (sender_)
-    sender_->set_wm_key_up(key_up);
-}
-
-int EventSenderBindings::WmChar() const {
-  if (sender_)
-    return sender_->wm_char();
-  return 0;
-}
-
-void EventSenderBindings::SetWmChar(int wm_char) {
-  if (sender_)
-    sender_->set_wm_char(wm_char);
-}
-
-int EventSenderBindings::WmDeadChar() const {
-  if (sender_)
-    return sender_->wm_dead_char();
-  return 0;
-}
-
-void EventSenderBindings::SetWmDeadChar(int dead_char) {
-  if (sender_)
-    sender_->set_wm_dead_char(dead_char);
-}
-
-int EventSenderBindings::WmSysKeyDown() const {
-  if (sender_)
-    return sender_->wm_sys_key_down();
-  return 0;
-}
-
-void EventSenderBindings::SetWmSysKeyDown(int key_down) {
-  if (sender_)
-    sender_->set_wm_sys_key_down(key_down);
-}
-
-int EventSenderBindings::WmSysKeyUp() const {
-  if (sender_)
-    return sender_->wm_sys_key_up();
-  return 0;
-}
-
-void EventSenderBindings::SetWmSysKeyUp(int key_up) {
-  if (sender_)
-    sender_->set_wm_sys_key_up(key_up);
-}
-
-int EventSenderBindings::WmSysChar() const {
-  if (sender_)
-    return sender_->wm_sys_char();
-  return 0;
-}
-
-void EventSenderBindings::SetWmSysChar(int sys_char) {
-  if (sender_)
-    sender_->set_wm_sys_char(sys_char);
-}
-
-int EventSenderBindings::WmSysDeadChar() const {
-  if (sender_)
-    return sender_->wm_sys_dead_char();
-  return 0;
-}
-
-void EventSenderBindings::SetWmSysDeadChar(int sys_dead_char) {
-  if (sender_)
-    sender_->set_wm_sys_dead_char(sys_dead_char);
-}
-#endif
-
-// EventSender -----------------------------------------------------------------
-
-WebMouseEvent::Button EventSender::last_button_type_ =
-    WebMouseEvent::Button::NoButton;
-
-EventSender::SavedEvent::SavedEvent()
-    : type(TYPE_UNSPECIFIED),
-      button_type(WebMouseEvent::Button::NoButton),
-      milliseconds(0),
-      modifiers(0) {}
-
-EventSender::EventSender(WebWidgetTestProxyBase* web_widget_test_proxy_base)
-    : web_widget_test_proxy_base_(web_widget_test_proxy_base),
-      replaying_saved_events_(false),
-      weak_factory_(this) {
-  Reset();
-}
-
-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 (widget() &&
-      current_pointer_state_[kRawMousePointerId].pressed_button_ !=
-          WebMouseEvent::Button::NoButton)
-    widget()->mouseCaptureLost();
-  current_pointer_state_.clear();
-  is_drag_mode_ = true;
-  force_layout_on_events_ = true;
-
-#if defined(OS_WIN)
-  wm_key_down_ = WM_KEYDOWN;
-  wm_key_up_ = WM_KEYUP;
-  wm_char_ = WM_CHAR;
-  wm_dead_char_ = WM_DEADCHAR;
-  wm_sys_key_down_ = WM_SYSKEYDOWN;
-  wm_sys_key_up_ = WM_SYSKEYUP;
-  wm_sys_char_ = WM_SYSCHAR;
-  wm_sys_dead_char_ = WM_SYSDEADCHAR;
-#endif
-
-  last_click_time_sec_ = 0;
-  last_click_pos_ = WebPoint(0, 0);
-  last_button_type_ = WebMouseEvent::Button::NoButton;
-  touch_points_.clear();
-  last_context_menu_data_.reset();
-  weak_factory_.InvalidateWeakPtrs();
-  current_gesture_location_ = WebPoint(0, 0);
-  mouse_event_queue_.clear();
-
-  time_offset_ms_ = 0;
-  click_count_ = 0;
-
-  touch_modifiers_ = 0;
-  touch_cancelable_ = true;
-  touch_points_.clear();
-}
-
-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(WebInputEvent::MouseDown,
-                          ModifiersForPointer(kRawMousePointerId),
-                          GetCurrentEventTimeSec());
-  InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
-                 current_pointer_state_[kRawMousePointerId].current_buttons_,
-                 current_pointer_state_[kRawMousePointerId].last_pos_,
-                 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;
-  current_drag_effects_allowed_ = mask;
-  current_drag_effect_ = mainFrameWidget()->dragTargetDragEnter(
-      drag_data, client_point, screen_point, current_drag_effects_allowed_,
-      modifiersWithButtons(
-          current_pointer_state_[kRawMousePointerId].modifiers_,
-          current_pointer_state_[kRawMousePointerId].current_buttons_));
-
-  // Finish processing events.
-  ReplaySavedEvents();
-}
-
-void EventSender::MouseDown(int button_number, int modifiers) {
-  PointerDown(button_number, modifiers,
-              WebPointerProperties::PointerType::Mouse, kRawMousePointerId, 0.0,
-              0, 0);
-}
-
-void EventSender::MouseUp(int button_number, int modifiers) {
-  PointerUp(button_number, modifiers, WebPointerProperties::PointerType::Mouse,
-            kRawMousePointerId, 0.0, 0, 0);
-}
-
-void EventSender::PointerDown(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);
-
-  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_;
-  }
-  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_,
-                        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(WebInputEvent::MouseUp, ModifiersForPointer(pointerId),
-                        GetCurrentEventTimeSec());
-    int click_count = pointerType == WebPointerProperties::PointerType::Mouse
-                          ? click_count_
-                          : 0;
-    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_ =
-      (modifiers == -1)
-          ? GetWebMouseEventModifierForButton(
-                current_pointer_state_[kRawMousePointerId].pressed_button_)
-          : modifiers & kButtonsInModifiers;
-}
-
-void EventSender::KeyDown(const std::string& code_str,
-                          int modifiers,
-                          KeyLocationCode location) {
-  // FIXME: I'm not exactly sure how we should convert the string to a key
-  // event. This seems to work in the cases I tested.
-  // FIXME: Should we also generate a KEY_UP?
-
-  bool generate_char = false;
-
-  // Convert \n -> VK_RETURN. Some layout tests use \n to mean "Enter", when
-  // Windows uses \r for "Enter".
-  int code = 0;
-  int text = 0;
-  bool needs_shift_key_modifier = false;
-  std::string domKeyString;
-  std::string domCodeString;
-
-  if ("Enter" == code_str) {
-    generate_char = true;
-    text = code = ui::VKEY_RETURN;
-    domKeyString.assign("Enter");
-    domCodeString.assign("Enter");
-  } else if ("ArrowRight" == code_str) {
-    code = ui::VKEY_RIGHT;
-    domKeyString.assign("ArrowRight");
-    domCodeString.assign("ArrowRight");
-  } else if ("ArrowDown" == code_str) {
-    code = ui::VKEY_DOWN;
-    domKeyString.assign("ArrowDown");
-    domCodeString.assign("ArrowDown");
-  } else if ("ArrowLeft" == code_str) {
-    code = ui::VKEY_LEFT;
-    domKeyString.assign("ArrowLeft");
-    domCodeString.assign("ArrowLeft");
-  } else if ("ArrowUp" == code_str) {
-    code = ui::VKEY_UP;
-    domKeyString.assign("ArrowUp");
-    domCodeString.assign("ArrowUp");
-  } else if ("Insert" == code_str) {
-    code = ui::VKEY_INSERT;
-    domKeyString.assign("Insert");
-    domCodeString.assign("Insert");
-  } else if ("Delete" == code_str) {
-    code = ui::VKEY_DELETE;
-    domKeyString.assign("Delete");
-    domCodeString.assign("Delete");
-  } else if ("PageUp" == code_str) {
-    code = ui::VKEY_PRIOR;
-    domKeyString.assign("PageUp");
-    domCodeString.assign("PageUp");
-  } else if ("PageDown" == code_str) {
-    code = ui::VKEY_NEXT;
-    domKeyString.assign("PageDown");
-    domCodeString.assign("PageDown");
-  } else if ("Home" == code_str) {
-    code = ui::VKEY_HOME;
-    domKeyString.assign("Home");
-    domCodeString.assign("Home");
-  } else if ("End" == code_str) {
-    code = ui::VKEY_END;
-    domKeyString.assign("End");
-    domCodeString.assign("End");
-  } else if ("PrintScreen" == code_str) {
-    code = ui::VKEY_SNAPSHOT;
-    domKeyString.assign("PrintScreen");
-    domCodeString.assign("PrintScreen");
-  } else if ("ContextMenu" == code_str) {
-    code = ui::VKEY_APPS;
-    domKeyString.assign("ContextMenu");
-    domCodeString.assign("ContextMenu");
-  } else if ("ControlLeft" == code_str) {
-    code = ui::VKEY_CONTROL;
-    domKeyString.assign("Control");
-    domCodeString.assign("ControlLeft");
-    location = DOMKeyLocationLeft;
-  } else if ("ControlRight" == code_str) {
-    code = ui::VKEY_CONTROL;
-    domKeyString.assign("Control");
-    domCodeString.assign("ControlRight");
-    location = DOMKeyLocationRight;
-  } else if ("ShiftLeft" == code_str) {
-    code = ui::VKEY_SHIFT;
-    domKeyString.assign("Shift");
-    domCodeString.assign("ShiftLeft");
-    location = DOMKeyLocationLeft;
-  } else if ("ShiftRight" == code_str) {
-    code = ui::VKEY_SHIFT;
-    domKeyString.assign("Shift");
-    domCodeString.assign("ShiftRight");
-    location = DOMKeyLocationRight;
-  } else if ("AltLeft" == code_str) {
-    code = ui::VKEY_MENU;
-    domKeyString.assign("Alt");
-    domCodeString.assign("AltLeft");
-    location = DOMKeyLocationLeft;
-  } else if ("AltRight" == code_str) {
-    code = ui::VKEY_MENU;
-    domKeyString.assign("Alt");
-    domCodeString.assign("AltRight");
-    location = DOMKeyLocationRight;
-  } else if ("NumLock" == code_str) {
-    code = ui::VKEY_NUMLOCK;
-    domKeyString.assign("NumLock");
-    domCodeString.assign("NumLock");
-  } else if ("Backspace" == code_str) {
-    code = ui::VKEY_BACK;
-    domKeyString.assign("Backspace");
-    domCodeString.assign("Backspace");
-  } else if ("Escape" == code_str) {
-    code = ui::VKEY_ESCAPE;
-    domKeyString.assign("Escape");
-    domCodeString.assign("Escape");
-  } else if ("Tab" == code_str) {
-    code = ui::VKEY_TAB;
-    domKeyString.assign("Tab");
-    domCodeString.assign("Tab");
-  } else if ("Cut" == code_str || "Copy" == code_str || "Paste" == code_str) {
-    // No valid KeyboardCode for Cut/Copy/Paste.
-    code = 0;
-    domKeyString.assign(code_str);
-    // It's OK to assign the same string as the DomCode strings happens to be
-    // the same for these keys.
-    domCodeString.assign(code_str);
-  } else {
-    // Compare the input string with the function-key names defined by the
-    // DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key
-    // name, set its key code.
-    for (int i = 1; i <= 24; ++i) {
-      std::string function_key_name = base::StringPrintf("F%d", i);
-      if (function_key_name == code_str) {
-        code = ui::VKEY_F1 + (i - 1);
-        domKeyString = function_key_name;
-        domCodeString = function_key_name;
-        break;
-      }
-    }
-    if (!code) {
-      base::string16 code_str16 = base::UTF8ToUTF16(code_str);
-      if (code_str16.size() != 1u) {
-        v8::Isolate* isolate = blink::mainThreadIsolate();
-        isolate->ThrowException(v8::Exception::TypeError(
-            gin::StringToV8(isolate, "Invalid web code.")));
-        return;
-      }
-      text = code = code_str16[0];
-      needs_shift_key_modifier = base::IsAsciiUpper(code & 0xFF);
-      if (base::IsAsciiLower(code & 0xFF))
-        code -= 'a' - 'A';
-      if (base::IsAsciiAlpha(code)) {
-        domKeyString.assign(code_str);
-        domCodeString.assign("Key");
-        domCodeString.push_back(
-            base::ToUpperASCII(static_cast<base::char16>(code)));
-      } else if (base::IsAsciiDigit(code)) {
-        domKeyString.assign(code_str);
-        domCodeString.assign("Digit");
-        domCodeString.push_back(code);
-      } else if (code == ' ') {
-        domKeyString.assign(code_str);
-        domCodeString.assign("Space");
-      } else if (code == 9) {
-        domKeyString.assign("Tab");
-        domCodeString.assign("Tab");
-      }
-      generate_char = true;
-    }
-
-    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(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);
-
-  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(WebInputEvent::MouseDown,
-                        ModifiersForPointer(kRawMousePointerId),
-                        GetCurrentEventTimeSec());
-    InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
-                   current_pointer_state_[kRawMousePointerId].current_buttons_,
-                   current_pointer_state_[kRawMousePointerId].last_pos_,
-                   click_count_, &event);
-    FinishDragAndDrop(event, blink::WebDragOperationNone);
-  }
-
-  delegate()->ClearEditCommand();
-
-  if (generate_char) {
-    WebKeyboardEvent event_char = event_up;
-    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.
-  // 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_);
-  }
-  WebMouseEvent event(WebInputEvent::MouseDown,
-                      ModifiersForPointer(kRawMousePointerId),
-                      GetCurrentEventTimeSec());
-  InitMouseEvent(WebMouseEvent::Button::Right,
-                 current_pointer_state_[kRawMousePointerId].current_buttons_,
-                 current_pointer_state_[kRawMousePointerId].last_pos_,
-                 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;
-
-  WebMouseEvent mouseUpEvent(WebInputEvent::MouseUp,
-                             ModifiersForPointer(kRawMousePointerId),
-                             GetCurrentEventTimeSec());
-  InitMouseEvent(WebMouseEvent::Button::Right,
-                 current_pointer_state_[kRawMousePointerId].current_buttons_,
-                 current_pointer_state_[kRawMousePointerId].last_pos_,
-                 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);
-}
-
-void EventSender::TextZoomOut() {
-  view()->setTextZoomFactor(view()->textZoomFactor() / 1.2f);
-}
-
-void EventSender::ZoomPageIn() {
-  const std::vector<WebViewTestProxyBase*>& window_list =
-      interfaces()->GetWindowList();
-
-  for (size_t i = 0; i < window_list.size(); ++i) {
-    window_list.at(i)->web_view()->setZoomLevel(
-        window_list.at(i)->web_view()->zoomLevel() + 1);
-  }
-}
-
-void EventSender::ZoomPageOut() {
-  const std::vector<WebViewTestProxyBase*>& window_list =
-      interfaces()->GetWindowList();
-
-  for (size_t i = 0; i < window_list.size(); ++i) {
-    window_list.at(i)->web_view()->setZoomLevel(
-        window_list.at(i)->web_view()->zoomLevel() - 1);
-  }
-}
-
-void EventSender::SetPageZoomFactor(double zoom_factor) {
-  const std::vector<WebViewTestProxyBase*>& window_list =
-      interfaces()->GetWindowList();
-
-  for (size_t i = 0; i < window_list.size(); ++i) {
-    window_list.at(i)->web_view()->setZoomLevel(std::log(zoom_factor) /
-                                                std::log(1.2));
-  }
-}
-
-void EventSender::ClearTouchPoints() {
-  touch_points_.clear();
-}
-
-void EventSender::ThrowTouchPointError() {
-  v8::Isolate* isolate = blink::mainThreadIsolate();
-  isolate->ThrowException(v8::Exception::TypeError(
-      gin::StringToV8(isolate, "Invalid touch point.")));
-}
-
-void EventSender::ReleaseTouchPoint(unsigned index) {
-  if (index >= touch_points_.size()) {
-    ThrowTouchPointError();
-    return;
-  }
-
-  WebTouchPoint* touch_point = &touch_points_[index];
-  touch_point->state = WebTouchPoint::StateReleased;
-}
-
-void EventSender::UpdateTouchPoint(unsigned index,
-                                   float x,
-                                   float y,
-                                   gin::Arguments* args) {
-  if (index >= touch_points_.size()) {
-    ThrowTouchPointError();
-    return;
-  }
-
-  WebTouchPoint* touch_point = &touch_points_[index];
-  touch_point->state = WebTouchPoint::StateMoved;
-  touch_point->position = WebFloatPoint(x, y);
-  touch_point->screenPosition = touch_point->position;
-
-  InitPointerProperties(args, touch_point, &touch_point->radiusX,
-                        &touch_point->radiusY);
-}
-
-void EventSender::CancelTouchPoint(unsigned index) {
-  if (index >= touch_points_.size()) {
-    ThrowTouchPointError();
-    return;
-  }
-
-  WebTouchPoint* touch_point = &touch_points_[index];
-  touch_point->state = WebTouchPoint::StateCancelled;
-}
-
-void EventSender::SetTouchModifier(const std::string& key_name,
-                                    bool set_mask) {
-  int mask = GetKeyModifier(key_name);
-
-  if (set_mask)
-    touch_modifiers_ |= mask;
-  else
-    touch_modifiers_ &= ~mask;
-}
-
-void EventSender::SetTouchCancelable(bool cancelable) {
-  touch_cancelable_ = cancelable;
-}
-
-void EventSender::DumpFilenameBeingDragged() {
-  if (current_drag_data_.isNull())
-    return;
-
-  WebVector<WebDragData::Item> items = current_drag_data_.items();
-  for (size_t i = 0; i < items.size(); ++i) {
-    if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
-      WebURL url = items[i].binaryDataSourceURL;
-      WebString filename_extension = items[i].binaryDataFilenameExtension;
-      WebString content_disposition = items[i].binaryDataContentDisposition;
-      base::FilePath filename =
-          net::GenerateFileName(url, content_disposition.utf8(),
-                                std::string(),   // referrer_charset
-                                std::string(),   // suggested_name
-                                std::string(),   // mime_type
-                                std::string());  // default_name
-#if defined(OS_WIN)
-      filename = filename.ReplaceExtension(filename_extension.utf16());
-#else
-      filename = filename.ReplaceExtension(filename_extension.utf8());
-#endif
-      delegate()->PrintMessage(std::string("Filename being dragged: ") +
-                               filename.AsUTF8Unsafe() + "\n");
-      return;
-    }
-  }
-}
-
-void EventSender::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;
-
-  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(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;
-
-  if (force_layout_on_events_)
-    widget()->updateAllLifecyclePhases();
-
-  HandleInputEventOnViewOrPopup(event);
-}
-
-bool EventSender::IsFlinging() const {
-  return view()->isFlinging();
-}
-
-void EventSender::GestureScrollFirstPoint(int x, int y) {
-  current_gesture_location_ = WebPoint(x, y);
-}
-
-void EventSender::TouchStart(gin::Arguments* args) {
-  SendCurrentTouchEvent(WebInputEvent::TouchStart, args);
-}
-
-void EventSender::TouchMove(gin::Arguments* args) {
-  SendCurrentTouchEvent(WebInputEvent::TouchMove, args);
-}
-
-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(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;
-    saved_event.milliseconds = milliseconds;
-    mouse_event_queue_.push_back(saved_event);
-  } else {
-    DoLeapForward(milliseconds);
-  }
-}
-
-void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) {
-  if (!current_drag_data_.isNull()) {
-    // Nested dragging not supported, fuzzer code a likely culprit.
-    // Cancel the current drag operation and throw an error.
-    KeyDown("Escape", 0, DOMKeyLocationStandard);
-    v8::Isolate* isolate = blink::mainThreadIsolate();
-    isolate->ThrowException(v8::Exception::Error(
-        gin::StringToV8(isolate,
-                        "Nested beginDragWithFiles() not supported.")));
-    return;
-  }
-  current_drag_data_.initialize();
-  WebVector<WebString> absolute_filenames(files.size());
-  for (size_t i = 0; i < files.size(); ++i) {
-    WebDragData::Item item;
-    item.storageType = WebDragData::Item::StorageTypeFilename;
-    item.filenameData = delegate()->GetAbsoluteWebStringFromUTF8Path(files[i]);
-    current_drag_data_.addItem(item);
-    absolute_filenames[i] = item.filenameData;
-  }
-  current_drag_data_.setFilesystemId(
-      delegate()->RegisterIsolatedFileSystem(absolute_filenames));
-  current_drag_effects_allowed_ = blink::WebDragOperationCopy;
-
-  const WebPoint& last_pos =
-      current_pointer_state_[kRawMousePointerId].last_pos_;
-  float scale = delegate()->GetWindowToViewportScale();
-  WebPoint scaled_last_pos(last_pos.x * scale, last_pos.y * scale);
-
-  // Provide a drag source.
-  mainFrameWidget()->dragTargetDragEnter(
-      current_drag_data_, scaled_last_pos, scaled_last_pos,
-      current_drag_effects_allowed_, 0);
-  // |is_drag_mode_| saves events and then replays them later. We don't
-  // need/want that.
-  is_drag_mode_ = false;
-
-  // Make the rest of eventSender think a drag is in progress.
-  current_pointer_state_[kRawMousePointerId].pressed_button_ =
-      WebMouseEvent::Button::Left;
-  current_pointer_state_[kRawMousePointerId].current_buttons_ |=
-      GetWebMouseEventModifierForButton(
-          current_pointer_state_[kRawMousePointerId].pressed_button_);
-}
-
-void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
-  WebTouchPoint touch_point;
-  touch_point.pointerType = WebPointerProperties::PointerType::Touch;
-  touch_point.state = WebTouchPoint::StatePressed;
-  touch_point.position = WebFloatPoint(x, y);
-  touch_point.screenPosition = touch_point.position;
-
-  int highest_id = -1;
-  for (size_t i = 0; i < touch_points_.size(); i++) {
-    if (touch_points_[i].id > highest_id)
-      highest_id = touch_points_[i].id;
-  }
-  touch_point.id = highest_id + 1;
-
-  InitPointerProperties(args, &touch_point, &touch_point.radiusX,
-                        &touch_point.radiusY);
-
-  // Set the touch point pressure to zero if it was not set by the caller
-  if (std::isnan(touch_point.force))
-      touch_point.force = 0.0;
-
-  touch_points_.push_back(touch_point);
-}
-
-void EventSender::GestureScrollBegin(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureScrollBegin, args);
-}
-
-void EventSender::GestureScrollEnd(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureScrollEnd, args);
-}
-
-void EventSender::GestureScrollUpdate(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureScrollUpdate, args);
-}
-
-void EventSender::GesturePinchBegin(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GesturePinchBegin, args);
-}
-
-void EventSender::GesturePinchEnd(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GesturePinchEnd, args);
-}
-
-void EventSender::GesturePinchUpdate(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GesturePinchUpdate, args);
-}
-
-void EventSender::GestureTap(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureTap, args);
-}
-
-void EventSender::GestureTapDown(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureTapDown, args);
-}
-
-void EventSender::GestureShowPress(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureShowPress, args);
-}
-
-void EventSender::GestureTapCancel(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureTapCancel, args);
-}
-
-void EventSender::GestureLongPress(gin::Arguments* args) {
-  GestureEvent(WebInputEvent::GestureLongPress, args);
-}
-
-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) {
-  // 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;
-  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();
-
-  double x;
-  double y;
-  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();
-  }
-
-  WebPointerProperties::PointerType pointerType =
-      WebPointerProperties::PointerType::Mouse;
-  int pointerId = 0;
-  float pressure = 0;
-  int tiltX = 0;
-  int tiltY = 0;
-  if (!getMousePenPointerProperties(args, pointerType, pointerId, pressure,
-                                    tiltX, tiltY))
-    return;
-
-  if (pointerType == WebPointerProperties::PointerType::Mouse &&
-      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;
-    current_pointer_state_[pointerId].modifiers_ = modifiers;
-    WebMouseEvent event(WebInputEvent::MouseMove,
-                        ModifiersForPointer(pointerId),
-                        GetCurrentEventTimeSec());
-    int click_count = pointerType == WebPointerProperties::PointerType::Mouse
-                          ? click_count_
-                          : 0;
-    InitMouseEventGeneric(
-        current_pointer_state_[kRawMousePointerId].pressed_button_,
-        current_pointer_state_[kRawMousePointerId].current_buttons_, mouse_pos,
-        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(WebInputEvent::MouseLeave,
-                      ModifiersForPointer(kRawMousePointerId),
-                      GetCurrentEventTimeSec());
-  InitMouseEvent(WebMouseEvent::Button::NoButton, 0,
-                 current_pointer_state_[kRawMousePointerId].last_pos_,
-                 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,
-                                  modifiers));
-}
-
-void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
-                                              int modifiers,
-                                              KeyLocationCode location) {
-  delegate()->PostTask(base::Bind(&EventSender::KeyDown,
-                                  weak_factory_.GetWeakPtr(), code_str,
-                                  modifiers, location));
-}
-
-double EventSender::GetCurrentEventTimeSec() {
-  return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF() +
-         time_offset_ms_ / 1000.0;
-}
-
-void EventSender::DoLeapForward(int milliseconds) {
-  time_offset_ms_ += milliseconds;
-}
-
-uint32_t EventSender::GetUniqueTouchEventId(gin::Arguments* args) {
-  uint32_t unique_touch_event_id;
-  if(!args->PeekNext().IsEmpty() && args->GetNext(&unique_touch_event_id))
-    return unique_touch_event_id;
-
-  return 0;
-}
-
-void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
-                                        gin::Arguments* args) {
-  uint32_t unique_touch_event_id = GetUniqueTouchEventId(args);
-
-  DCHECK_GT(static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap),
-            touch_points_.size());
-  if (force_layout_on_events_)
-    widget()->updateAllLifecyclePhases();
-
-  WebTouchEvent touch_event(type, touch_modifiers_, GetCurrentEventTimeSec());
-  touch_event.dispatchType = touch_cancelable_
-                                 ? WebInputEvent::Blocking
-                                 : WebInputEvent::EventNonBlocking;
-  touch_event.movedBeyondSlopRegion = true;
-  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(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;
-    }
-    if (device_string == kSourceDeviceStringTouchpad) {
-      event.sourceDevice = blink::WebGestureDeviceTouchpad;
-    } else if (device_string == kSourceDeviceStringTouchscreen) {
-      event.sourceDevice = blink::WebGestureDeviceTouchscreen;
-    } else {
-      args->ThrowError();
-      return;
-    }
-  }
-
-  double x;
-  double y;
-  if (!args->GetNext(&x) || !args->GetNext(&y)) {
-    args->ThrowError();
-    return;
-  }
-
-  switch (type) {
-    case WebInputEvent::GestureScrollUpdate:
-    {
-      bool preventPropagation = false;
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&preventPropagation)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      if (!GetScrollUnits(args, &event.data.scrollUpdate.deltaUnits))
-        return;
-
-      event.data.scrollUpdate.deltaX = static_cast<float>(x);
-      event.data.scrollUpdate.deltaY = static_cast<float>(y);
-      event.data.scrollUpdate.preventPropagation = preventPropagation;
-      event.x = current_gesture_location_.x;
-      event.y = current_gesture_location_.y;
-      current_gesture_location_.x =
-          current_gesture_location_.x + event.data.scrollUpdate.deltaX;
-      current_gesture_location_.y =
-          current_gesture_location_.y + event.data.scrollUpdate.deltaY;
-      break;
-    }
-    case WebInputEvent::GestureScrollBegin:
-      current_gesture_location_ = WebPoint(x, y);
-      event.x = current_gesture_location_.x;
-      event.y = current_gesture_location_.y;
-      break;
-    case WebInputEvent::GestureScrollEnd:
-    case WebInputEvent::GestureFlingStart:
-      event.x = current_gesture_location_.x;
-      event.y = current_gesture_location_.y;
-      break;
-    case WebInputEvent::GesturePinchBegin:
-    case WebInputEvent::GesturePinchEnd:
-      current_gesture_location_ = WebPoint(x, y);
-      event.x = current_gesture_location_.x;
-      event.y = current_gesture_location_.y;
-      break;
-    case WebInputEvent::GesturePinchUpdate:
-    {
-      float scale = 1;
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&scale)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      event.data.pinchUpdate.scale = scale;
-      current_gesture_location_ = WebPoint(x, y);
-      event.x = current_gesture_location_.x;
-      event.y = current_gesture_location_.y;
-      break;
-    }
-    case WebInputEvent::GestureTap:
-    {
-      float tap_count = 1;
-      float width = 30;
-      float height = 30;
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&tap_count)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&width)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&height)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      event.data.tap.tapCount = tap_count;
-      event.data.tap.width = width;
-      event.data.tap.height = height;
-      event.x = x;
-      event.y = y;
-      break;
-    }
-    case WebInputEvent::GestureTapUnconfirmed:
-      if (!args->PeekNext().IsEmpty()) {
-        float tap_count;
-        if (!args->GetNext(&tap_count)) {
-          args->ThrowError();
-          return;
-        }
-        event.data.tap.tapCount = tap_count;
-      } else {
-        event.data.tap.tapCount = 1;
-      }
-      event.x = x;
-      event.y = y;
-      break;
-    case WebInputEvent::GestureTapDown:
-    {
-      float width = 30;
-      float height = 30;
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&width)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&height)) {
-          args->ThrowError();
-          return;
-        }
-      }
-      event.x = x;
-      event.y = y;
-      event.data.tapDown.width = width;
-      event.data.tapDown.height = height;
-      break;
-    }
-    case WebInputEvent::GestureShowPress:
-    {
-      float width = 30;
-      float height = 30;
-      if (!args->PeekNext().IsEmpty()) {
-        if (!args->GetNext(&width)) {
-          args->ThrowError();
-          return;
-        }
-        if (!args->PeekNext().IsEmpty()) {
-          if (!args->GetNext(&height)) {
-            args->ThrowError();
-            return;
-          }
-        }
-      }
-      event.x = x;
-      event.y = y;
-      event.data.showPress.width = width;
-      event.data.showPress.height = height;
-      break;
-    }
-    case WebInputEvent::GestureTapCancel:
-      event.x = x;
-      event.y = y;
-      break;
-    case WebInputEvent::GestureLongPress:
-    case WebInputEvent::GestureLongTap:
-      event.x = x;
-      event.y = y;
-      if (!args->PeekNext().IsEmpty()) {
-        float width;
-        if (!args->GetNext(&width)) {
-          args->ThrowError();
-          return;
-        }
-        event.data.longPress.width = width;
-        if (!args->PeekNext().IsEmpty()) {
-          float height;
-          if (!args->GetNext(&height)) {
-            args->ThrowError();
-            return;
-          }
-          event.data.longPress.height = height;
-        }
-      }
-      break;
-    case WebInputEvent::GestureTwoFingerTap:
-      event.x = x;
-      event.y = y;
-      if (!args->PeekNext().IsEmpty()) {
-        float first_finger_width;
-        if (!args->GetNext(&first_finger_width)) {
-          args->ThrowError();
-          return;
-        }
-        event.data.twoFingerTap.firstFingerWidth = first_finger_width;
-        if (!args->PeekNext().IsEmpty()) {
-          float first_finger_height;
-          if (!args->GetNext(&first_finger_height)) {
-            args->ThrowError();
-            return;
-          }
-          event.data.twoFingerTap.firstFingerHeight = first_finger_height;
-        }
-      }
-      break;
-    default:
-      NOTREACHED();
-  }
-
-  event.uniqueTouchEventId = GetUniqueTouchEventId(args);
-
-  event.globalX = event.x;
-  event.globalY = event.y;
-
-  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(WebInputEvent::MouseDown,
-                              ModifiersForPointer(kRawMousePointerId),
-                              GetCurrentEventTimeSec());
-
-    InitMouseEvent(current_pointer_state_[kRawMousePointerId].pressed_button_,
-                   current_pointer_state_[kRawMousePointerId].current_buttons_,
-                   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;
-  }
-}
-
-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;
-  double vertical;
-  if (!args->GetNext(&horizontal) || !args->GetNext(&vertical)) {
-    args->ThrowError();
-    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);
-          }
-        }
-      }
-    }
-  }
-
-  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_,
-                 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;
-  } else {
-    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()) {
-    double radius_x;
-    if (!args->GetNext(&radius_x)) {
-      args->ThrowError();
-      return;
-    }
-
-    double radius_y = radius_x;
-    if (!args->PeekNext().IsEmpty()) {
-      if (!args->GetNext(&radius_y)) {
-        args->ThrowError();
-        return;
-      }
-    }
-
-    *radius_x_pointer = static_cast<float>(radius_x);
-    *radius_y_pointer = static_cast<float>(radius_y);
-  }
-
-  if (!args->PeekNext().IsEmpty()) {
-    double force;
-    if (!args->GetNext(&force)) {
-      args->ThrowError();
-      return;
-    }
-    e->force = static_cast<float>(force);
-  }
-
-  if (!args->PeekNext().IsEmpty()) {
-    int tiltX, tiltY;
-    if (!args->GetNext(&tiltX) || !args->GetNext(&tiltY)) {
-      args->ThrowError();
-      return;
-    }
-    e->tiltX = tiltX;
-    e->tiltY = tiltY;
-  }
-
-  if (!getPointerType(args, false, e->pointerType))
-    return;
-}
-
-void EventSender::FinishDragAndDrop(const WebMouseEvent& raw_event,
-                                    blink::WebDragOperation drag_effect) {
-  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_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).
-    mainFrameWidget()->dragTargetDrop(current_drag_data_, client_point,
-                                      screen_point, event->modifiers());
-  } else {
-    mainFrameWidget()->dragTargetDragLeave(blink::WebPoint(),
-                                           blink::WebPoint());
-  }
-  current_drag_data_.reset();
-  mainFrameWidget()->dragSourceEndedAt(client_point, screen_point,
-                                       current_drag_effect_);
-  mainFrameWidget()->dragSourceSystemDragEnded();
-}
-
-void EventSender::DoDragAfterMouseUp(const WebMouseEvent& 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;
-
-  last_click_time_sec_ = event->timeStampSeconds();
-  last_click_pos_ = current_pointer_state_[kRawMousePointerId].last_pos_;
-
-  // If we're in a drag operation, complete it.
-  if (current_drag_data_.isNull())
-    return;
-
-  WebPoint client_point(event->x, event->y);
-  WebPoint screen_point(event->globalX, event->globalY);
-  blink::WebDragOperation drag_effect = mainFrameWidget()->dragTargetDragOver(
-      client_point, screen_point, current_drag_effects_allowed_,
-      event->modifiers());
-
-  // Bail if dragover caused cancellation.
-  if (current_drag_data_.isNull())
-    return;
-
-  FinishDragAndDrop(raw_event, drag_effect);
-}
-
-void EventSender::DoDragAfterMouseMove(const WebMouseEvent& raw_event) {
-  if (current_pointer_state_[kRawMousePointerId].pressed_button_ ==
-          WebMouseEvent::Button::NoButton ||
-      current_drag_data_.isNull()) {
-    return;
-  }
-
-  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_effect_ = mainFrameWidget()->dragTargetDragOver(
-      client_point, screen_point, current_drag_effects_allowed_,
-      event->modifiers());
-}
-
-void EventSender::ReplaySavedEvents() {
-  replaying_saved_events_ = true;
-  while (!mouse_event_queue_.empty()) {
-    SavedEvent e = mouse_event_queue_.front();
-    mouse_event_queue_.pop_front();
-
-    switch (e.type) {
-      case SavedEvent::TYPE_MOUSE_MOVE: {
-        current_pointer_state_[kRawMousePointerId].modifiers_ = e.modifiers;
-        WebMouseEvent event(WebInputEvent::MouseMove,
-                            ModifiersForPointer(kRawMousePointerId),
-                            GetCurrentEventTimeSec());
-        InitMouseEvent(
-            current_pointer_state_[kRawMousePointerId].pressed_button_,
-            current_pointer_state_[kRawMousePointerId].current_buttons_, e.pos,
-            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(WebInputEvent::MouseUp,
-                            ModifiersForPointer(kRawMousePointerId),
-                            GetCurrentEventTimeSec());
-        InitMouseEvent(
-            e.button_type,
-            current_pointer_state_[kRawMousePointerId].current_buttons_,
-            current_pointer_state_[kRawMousePointerId].last_pos_, click_count_,
-            &event);
-        HandleInputEventOnViewOrPopup(event);
-        DoDragAfterMouseUp(event);
-        break;
-      }
-      default:
-        NOTREACHED();
-    }
-  }
-
-  replaying_saved_events_ = false;
-}
-
-WebInputEventResult EventSender::HandleInputEventOnViewOrPopup(
-    const WebInputEvent& raw_event) {
-  last_event_timestamp_ = raw_event.timeStampSeconds();
-
-  WebPagePopup* popup = widget()->pagePopup();
-  if (popup && !WebInputEvent::isKeyboardEventType(raw_event.type())) {
-    // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the
-    // event does not have to be converted.
-    std::unique_ptr<WebInputEvent> scaled_event = ui::ScaleWebInputEvent(
-        raw_event, delegate()->GetWindowToViewportScale());
-    const WebInputEvent* popup_friendly_event =
-        scaled_event.get() ? scaled_event.get() : &raw_event;
-    return popup->handleInputEvent(
-        blink::WebCoalescedInputEvent(*popup_friendly_event));
-  }
-
-  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(blink::WebCoalescedInputEvent(*event));
-}
-
-void EventSender::SendGesturesForMouseWheelEvent(
-    const WebMouseWheelEvent wheel_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(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(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()
-      ->test_interfaces();
-}
-
-WebTestDelegate* EventSender::delegate() {
-  return web_widget_test_proxy_base_->web_view_test_proxy_base()->delegate();
-}
-
-const blink::WebView* EventSender::view() const {
-  return web_widget_test_proxy_base_->web_view_test_proxy_base()->web_view();
-}
-
-blink::WebView* EventSender::view() {
-  return web_widget_test_proxy_base_->web_view_test_proxy_base()->web_view();
-}
-
-blink::WebWidget* EventSender::widget() {
-  return web_widget_test_proxy_base_->web_widget();
-}
-
-blink::WebFrameWidget* EventSender::mainFrameWidget() {
-  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