components/test_runner/event_sender.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/test_runner/event_sender.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "components/test_runner/mock_spell_check.h"
  12 #include "components/test_runner/test_interfaces.h"
  13 #include "components/test_runner/web_test_delegate.h"
  14 #include "components/test_runner/web_test_proxy.h"
  15 #include "gin/handle.h"
  16 #include "gin/object_template_builder.h"
  17 #include "gin/wrappable.h"
  18 #include "third_party/WebKit/public/platform/WebString.h"
  19 #include "third_party/WebKit/public/platform/WebVector.h"
  20 #include "third_party/WebKit/public/web/WebContextMenuData.h"
  21 #include "third_party/WebKit/public/web/WebFrame.h"
  22 #include "third_party/WebKit/public/web/WebKit.h"
  23 #include "third_party/WebKit/public/web/WebPagePopup.h"
  24 #include "third_party/WebKit/public/web/WebView.h"
  25 #include "ui/events/keycodes/dom/keycode_converter.h"
  26 #include "ui/events/keycodes/keyboard_codes.h"
  27 #include "v8/include/v8.h"
  28
  29 using blink::WebContextMenuData;
  30 using blink::WebDragData;
  31 using blink::WebDragOperationsMask;
  32 using blink::WebFloatPoint;
  33 using blink::WebFrame;
  34 using blink::WebGestureEvent;
  35 using blink::WebInputEvent;
  36 using blink::WebKeyboardEvent;
  37 using blink::WebMenuItemInfo;
  38 using blink::WebMouseEvent;
  39 using blink::WebMouseWheelEvent;
  40 using blink::WebPagePopup;
  41 using blink::WebPoint;
  42 using blink::WebString;
  43 using blink::WebTouchEvent;
  44 using blink::WebTouchPoint;
  45 using blink::WebVector;
  46 using blink::WebView;
  47
  48 namespace test_runner {
  49
  50 namespace {
  51
  52 void InitMouseEvent(WebInputEvent::Type t,
  53                     WebMouseEvent::Button b,
  54                     const WebPoint& pos,
  55                     double time_stamp,
  56                     int click_count,
  57                     int modifiers,
  58                     WebMouseEvent* e) {
  59   e->type = t;
  60   e->button = b;
  61   e->modifiers = modifiers;
  62   e->x = pos.x;
  63   e->y = pos.y;
  64   e->globalX = pos.x;
  65   e->globalY = pos.y;
  66   e->timeStampSeconds = time_stamp;
  67   e->clickCount = click_count;
  68 }
  69
  70 int GetKeyModifier(const std::string& modifier_name) {
  71   const char* characters = modifier_name.c_str();
  72   if (!strcmp(characters, "ctrlKey")
  73 #ifndef __APPLE__
  74       || !strcmp(characters, "addSelectionKey")
  75 #endif
  76       ) {
  77     return WebInputEvent::ControlKey;
  78   } else if (!strcmp(characters, "shiftKey") ||
  79              !strcmp(characters, "rangeSelectionKey")) {
  80     return WebInputEvent::ShiftKey;
  81   } else if (!strcmp(characters, "altKey")) {
  82     return WebInputEvent::AltKey;
  83 #ifdef __APPLE__
  84   } else if (!strcmp(characters, "metaKey") ||
  85              !strcmp(characters, "addSelectionKey")) {
  86     return WebInputEvent::MetaKey;
  87 #else
  88   } else if (!strcmp(characters, "metaKey")) {
  89     return WebInputEvent::MetaKey;
  90 #endif
  91   } else if (!strcmp(characters, "autoRepeat")) {
  92     return WebInputEvent::IsAutoRepeat;
  93   } else if (!strcmp(characters, "copyKey")) {
  94 #ifdef __APPLE__
  95     return WebInputEvent::AltKey;
  96 #else
  97     return WebInputEvent::ControlKey;
  98 #endif
  99   } else if (!strcmp(characters, "leftButton")) {
 100     return WebInputEvent::LeftButtonDown;
 101   } else if (!strcmp(characters, "middleButton")) {
 102     return WebInputEvent::MiddleButtonDown;
 103   } else if (!strcmp(characters, "rightButton")) {
 104     return WebInputEvent::RightButtonDown;
 105   }
 106
 107   return 0;
 108 }
 109
 110 int GetKeyModifiers(const std::vector<std::string>& modifier_names) {
 111   int modifiers = 0;
 112   for (std::vector<std::string>::const_iterator it = modifier_names.begin();
 113        it != modifier_names.end(); ++it) {
 114     modifiers |= GetKeyModifier(*it);
 115   }
 116   return modifiers;
 117 }
 118
 119 int GetKeyModifiersFromV8(v8::Isolate* isolate, v8::Local<v8::Value> value) {
 120   std::vector<std::string> modifier_names;
 121   if (value->IsString()) {
 122     modifier_names.push_back(gin::V8ToString(value));
 123   } else if (value->IsArray()) {
 124     gin::Converter<std::vector<std::string> >::FromV8(
 125         isolate, value, &modifier_names);
 126   }
 127   return GetKeyModifiers(modifier_names);
 128 }
 129
 130 // Maximum distance (in space and time) for a mouse click to register as a
 131 // double or triple click.
 132 const double kMultipleClickTimeSec = 1;
 133 const int kMultipleClickRadiusPixels = 5;
 134 const char kSubMenuDepthIdentifier[] = "_";
 135 const char kSubMenuIdentifier[] = " >";
 136 const char kSeparatorIdentifier[] = "---------";
 137 const char kDisabledIdentifier[] = "#";
 138 const char kCheckedIdentifier[] = "*";
 139
 140 bool OutsideMultiClickRadius(const WebPoint& a, const WebPoint& b) {
 141   return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) >
 142          kMultipleClickRadiusPixels * kMultipleClickRadiusPixels;
 143 }
 144
 145 void PopulateCustomItems(const WebVector<WebMenuItemInfo>& customItems,
 146     const std::string& prefix, std::vector<std::string>* strings) {
 147   for (size_t i = 0; i < customItems.size(); ++i) {
 148     std::string prefixCopy = prefix;
 149     if (!customItems[i].enabled)
 150         prefixCopy = kDisabledIdentifier + prefix;
 151     if (customItems[i].checked)
 152         prefixCopy = kCheckedIdentifier + prefix;
 153     if (customItems[i].type == blink::WebMenuItemInfo::Separator) {
 154       strings->push_back(prefixCopy + kSeparatorIdentifier);
 155     } else if (customItems[i].type == blink::WebMenuItemInfo::SubMenu) {
 156       strings->push_back(prefixCopy + customItems[i].label.utf8() +
 157           customItems[i].icon.utf8() + kSubMenuIdentifier);
 158       PopulateCustomItems(customItems[i].subMenuItems, prefixCopy +
 159           kSubMenuDepthIdentifier, strings);
 160     } else {
 161       strings->push_back(prefixCopy + customItems[i].label.utf8() +
 162           customItems[i].icon.utf8());
 163     }
 164   }
 165 }
 166
 167 // Because actual context menu is implemented by the browser side,
 168 // this function does only what LayoutTests are expecting:
 169 // - Many test checks the count of items. So returning non-zero value makes
 170 // sense.
 171 // - Some test compares the count before and after some action. So changing the
 172 // count based on flags also makes sense. This function is doing such for some
 173 // flags.
 174 // - Some test even checks actual string content. So providing it would be also
 175 // helpful.
 176 std::vector<std::string> MakeMenuItemStringsFor(
 177     WebContextMenuData* context_menu,
 178     WebTestDelegate* delegate) {
 179   // These constants are based on Safari's context menu because tests are made
 180   // for it.
 181   static const char* kNonEditableMenuStrings[] = {
 182     "Back",
 183     "Reload Page",
 184     "Open in Dashbaord",
 185     "<separator>",
 186     "View Source",
 187     "Save Page As",
 188     "Print Page",
 189     "Inspect Element",
 190     0
 191   };
 192   static const char* kEditableMenuStrings[] = {
 193     "Cut",
 194     "Copy",
 195     "<separator>",
 196     "Paste",
 197     "Spelling and Grammar",
 198     "Substitutions, Transformations",
 199     "Font",
 200     "Speech",
 201     "Paragraph Direction",
 202     "<separator>",
 203     0
 204   };
 205
 206   // This is possible because mouse events are cancelleable.
 207   if (!context_menu)
 208     return std::vector<std::string>();
 209
 210   std::vector<std::string> strings;
 211
 212   // Populate custom menu items if provided by blink.
 213   PopulateCustomItems(context_menu->customItems, "", &strings);
 214
 215   if (context_menu->isEditable) {
 216     for (const char** item = kEditableMenuStrings; *item; ++item) {
 217       strings.push_back(*item);
 218     }
 219     WebVector<WebString> suggestions;
 220     MockSpellCheck::FillSuggestionList(context_menu->misspelledWord,
 221                                        &suggestions);
 222     for (size_t i = 0; i < suggestions.size(); ++i) {
 223       strings.push_back(suggestions[i].utf8());
 224     }
 225   } else {
 226     for (const char** item = kNonEditableMenuStrings; *item; ++item) {
 227       strings.push_back(*item);
 228     }
 229   }
 230
 231   return strings;
 232 }
 233
 234 // How much we should scroll per event - the value here is chosen to match the
 235 // WebKit impl and layout test results.
 236 const float kScrollbarPixelsPerTick = 40.0f;
 237
 238 WebMouseEvent::Button GetButtonTypeFromButtonNumber(int button_code) {
 239   if (!button_code)
 240     return WebMouseEvent::ButtonLeft;
 241   if (button_code == 2)
 242     return WebMouseEvent::ButtonRight;
 243   return WebMouseEvent::ButtonMiddle;
 244 }
 245
 246 class MouseDownTask : public WebMethodTask<EventSender> {
 247  public:
 248   MouseDownTask(EventSender* obj, int button_number, int modifiers)
 249       : WebMethodTask<EventSender>(obj),
 250         button_number_(button_number),
 251         modifiers_(modifiers) {}
 252
 253   void RunIfValid() override { object_->MouseDown(button_number_, modifiers_); }
 254
 255  private:
 256   int button_number_;
 257   int modifiers_;
 258 };
 259
 260 class MouseUpTask : public WebMethodTask<EventSender> {
 261  public:
 262   MouseUpTask(EventSender* obj, int button_number, int modifiers)
 263       : WebMethodTask<EventSender>(obj),
 264         button_number_(button_number),
 265         modifiers_(modifiers) {}
 266
 267   void RunIfValid() override { object_->MouseUp(button_number_, modifiers_); }
 268
 269  private:
 270   int button_number_;
 271   int modifiers_;
 272 };
 273
 274 class KeyDownTask : public WebMethodTask<EventSender> {
 275  public:
 276   KeyDownTask(EventSender* obj,
 277               const std::string code_str,
 278               int modifiers,
 279               KeyLocationCode location)
 280       : WebMethodTask<EventSender>(obj),
 281         code_str_(code_str),
 282         modifiers_(modifiers),
 283         location_(location) {}
 284
 285   void RunIfValid() override {
 286     object_->KeyDown(code_str_, modifiers_, location_);
 287   }
 288
 289  private:
 290   std::string code_str_;
 291   int modifiers_;
 292   KeyLocationCode location_;
 293 };
 294
 295 bool NeedsShiftModifier(int keyCode) {
 296   // If code is an uppercase letter, assign a SHIFT key to eventDown.modifier.
 297   return (keyCode & 0xFF) >= 'A' && (keyCode & 0xFF) <= 'Z';
 298 }
 299
 300 // Get the edit command corresponding to a keyboard event.
 301 // Returns true if the specified event corresponds to an edit command, the name
 302 // of the edit command will be stored in |*name|.
 303 bool GetEditCommand(const WebKeyboardEvent& event, std::string* name) {
 304 #if defined(OS_MACOSX)
 305 // We only cares about Left,Right,Up,Down keys with Command or Command+Shift
 306 // modifiers. These key events correspond to some special movement and
 307 // selection editor commands. These keys will be marked as system key, which
 308 // prevents them from being handled. Thus they must be handled specially.
 309   if ((event.modifiers & ~WebKeyboardEvent::ShiftKey) !=
 310       WebKeyboardEvent::MetaKey)
 311     return false;
 312
 313   switch (event.windowsKeyCode) {
 314     case ui::VKEY_LEFT:
 315       *name = "MoveToBeginningOfLine";
 316       break;
 317     case ui::VKEY_RIGHT:
 318       *name = "MoveToEndOfLine";
 319       break;
 320     case ui::VKEY_UP:
 321       *name = "MoveToBeginningOfDocument";
 322       break;
 323     case ui::VKEY_DOWN:
 324       *name = "MoveToEndOfDocument";
 325       break;
 326     default:
 327       return false;
 328   }
 329
 330   if (event.modifiers & WebKeyboardEvent::ShiftKey)
 331     name->append("AndModifySelection");
 332
 333   return true;
 334 #else
 335   return false;
 336 #endif
 337 }
 338
 339 bool IsSystemKeyEvent(const WebKeyboardEvent& event) {
 340 #if defined(OS_MACOSX)
 341   return event.modifiers & WebInputEvent::MetaKey &&
 342       event.windowsKeyCode != ui::VKEY_B &&
 343       event.windowsKeyCode != ui::VKEY_I;
 344 #else
 345   return !!(event.modifiers & WebInputEvent::AltKey);
 346 #endif
 347 }
 348
 349 const char* kSourceDeviceStringTouchpad = "touchpad";
 350 const char* kSourceDeviceStringTouchscreen = "touchscreen";
 351
 352 const char* kPointerTypeStringUnknown = "";
 353 const char* kPointerTypeStringMouse = "mouse";
 354 const char* kPointerTypeStringPen = "pen";
 355 const char* kPointerTypeStringTouch = "touch";
 356
 357 }  // namespace
 358
 359 class EventSenderBindings : public gin::Wrappable<EventSenderBindings> {
 360  public:
 361   static gin::WrapperInfo kWrapperInfo;
 362
 363   static void Install(base::WeakPtr<EventSender> sender,
 364                       blink::WebFrame* frame);
 365
 366  private:
 367   explicit EventSenderBindings(base::WeakPtr<EventSender> sender);
 368   ~EventSenderBindings() override;
 369
 370   // gin::Wrappable:
 371   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
 372       v8::Isolate* isolate) override;
 373
 374   // Bound methods:
 375   void EnableDOMUIEventLogging();
 376   void FireKeyboardEventsToElement();
 377   void ClearKillRing();
 378   std::vector<std::string> ContextClick();
 379   void TextZoomIn();
 380   void TextZoomOut();
 381   void ZoomPageIn();
 382   void ZoomPageOut();
 383   void SetPageZoomFactor(double factor);
 384   void ClearTouchPoints();
 385   void ReleaseTouchPoint(unsigned index);
 386   void UpdateTouchPoint(unsigned index,
 387                         double x,
 388                         double y,
 389                         gin::Arguments* args);
 390   void CancelTouchPoint(unsigned index);
 391   void SetTouchModifier(const std::string& key_name, bool set_mask);
 392   void SetTouchCancelable(bool cancelable);
 393   void DumpFilenameBeingDragged();
 394   void GestureFlingCancel();
 395   void GestureFlingStart(float x,
 396                          float y,
 397                          float velocity_x,
 398                          float velocity_y,
 399                          gin::Arguments* args);
 400   void GestureScrollFirstPoint(int x, int y);
 401   void TouchStart();
 402   void TouchMove();
 403   void TouchMoveCausingScrollIfUncanceled();
 404   void TouchCancel();
 405   void TouchEnd();
 406   void LeapForward(int milliseconds);
 407   void BeginDragWithFiles(const std::vector<std::string>& files);
 408   void AddTouchPoint(double x, double y, gin::Arguments* args);
 409   void MouseDragBegin();
 410   void MouseDragEnd();
 411   void GestureScrollBegin(gin::Arguments* args);
 412   void GestureScrollEnd(gin::Arguments* args);
 413   void GestureScrollUpdate(gin::Arguments* args);
 414   void GesturePinchBegin(gin::Arguments* args);
 415   void GesturePinchEnd(gin::Arguments* args);
 416   void GesturePinchUpdate(gin::Arguments* args);
 417   void GestureTap(gin::Arguments* args);
 418   void GestureTapDown(gin::Arguments* args);
 419   void GestureShowPress(gin::Arguments* args);
 420   void GestureTapCancel(gin::Arguments* args);
 421   void GestureLongPress(gin::Arguments* args);
 422   void GestureLongTap(gin::Arguments* args);
 423   void GestureTwoFingerTap(gin::Arguments* args);
 424   void ContinuousMouseScrollBy(gin::Arguments* args);
 425   void MouseMoveTo(gin::Arguments* args);
 426   void MouseLeave();
 427   void TrackpadScrollBegin();
 428   void TrackpadScroll(gin::Arguments* args);
 429   void TrackpadScrollEnd();
 430   void MouseScrollBy(gin::Arguments* args);
 431   // TODO(erikchen): Remove MouseMomentumBegin once CL 282743002 has landed.
 432   void MouseMomentumBegin();
 433   void MouseMomentumBegin2(gin::Arguments* args);
 434   void MouseMomentumScrollBy(gin::Arguments* args);
 435   void MouseMomentumEnd();
 436   void ScheduleAsynchronousClick(gin::Arguments* args);
 437   void ScheduleAsynchronousKeyDown(gin::Arguments* args);
 438   void MouseDown(gin::Arguments* args);
 439   void MouseUp(gin::Arguments* args);
 440   void KeyDown(gin::Arguments* args);
 441
 442   // Binding properties:
 443   bool ForceLayoutOnEvents() const;
 444   void SetForceLayoutOnEvents(bool force);
 445   bool IsDragMode() const;
 446   void SetIsDragMode(bool drag_mode);
 447
 448 #if defined(OS_WIN)
 449   int WmKeyDown() const;
 450   void SetWmKeyDown(int key_down);
 451
 452   int WmKeyUp() const;
 453   void SetWmKeyUp(int key_up);
 454
 455   int WmChar() const;
 456   void SetWmChar(int wm_char);
 457
 458   int WmDeadChar() const;
 459   void SetWmDeadChar(int dead_char);
 460
 461   int WmSysKeyDown() const;
 462   void SetWmSysKeyDown(int key_down);
 463
 464   int WmSysKeyUp() const;
 465   void SetWmSysKeyUp(int key_up);
 466
 467   int WmSysChar() const;
 468   void SetWmSysChar(int sys_char);
 469
 470   int WmSysDeadChar() const;
 471   void SetWmSysDeadChar(int sys_dead_char);
 472 #endif
 473
 474   base::WeakPtr<EventSender> sender_;
 475
 476   DISALLOW_COPY_AND_ASSIGN(EventSenderBindings);
 477 };
 478
 479 gin::WrapperInfo EventSenderBindings::kWrapperInfo = {gin::kEmbedderNativeGin};
 480
 481 EventSenderBindings::EventSenderBindings(base::WeakPtr<EventSender> sender)
 482     : sender_(sender) {
 483 }
 484
 485 EventSenderBindings::~EventSenderBindings() {}
 486
 487 // static
 488 void EventSenderBindings::Install(base::WeakPtr<EventSender> sender,
 489                                   WebFrame* frame) {
 490   v8::Isolate* isolate = blink::mainThreadIsolate();
 491   v8::HandleScope handle_scope(isolate);
 492   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
 493   if (context.IsEmpty())
 494     return;
 495
 496   v8::Context::Scope context_scope(context);
 497
 498   gin::Handle<EventSenderBindings> bindings =
 499       gin::CreateHandle(isolate, new EventSenderBindings(sender));
 500   if (bindings.IsEmpty())
 501     return;
 502   v8::Local<v8::Object> global = context->Global();
 503   global->Set(gin::StringToV8(isolate, "eventSender"), bindings.ToV8());
 504 }
 505
 506 gin::ObjectTemplateBuilder
 507 EventSenderBindings::GetObjectTemplateBuilder(v8::Isolate* isolate) {
 508   return gin::Wrappable<EventSenderBindings>::GetObjectTemplateBuilder(isolate)
 509       .SetMethod("enableDOMUIEventLogging",
 510                  &EventSenderBindings::EnableDOMUIEventLogging)
 511       .SetMethod("fireKeyboardEventsToElement",
 512                  &EventSenderBindings::FireKeyboardEventsToElement)
 513       .SetMethod("clearKillRing", &EventSenderBindings::ClearKillRing)
 514       .SetMethod("contextClick", &EventSenderBindings::ContextClick)
 515       .SetMethod("textZoomIn", &EventSenderBindings::TextZoomIn)
 516       .SetMethod("textZoomOut", &EventSenderBindings::TextZoomOut)
 517       .SetMethod("zoomPageIn", &EventSenderBindings::ZoomPageIn)
 518       .SetMethod("zoomPageOut", &EventSenderBindings::ZoomPageOut)
 519       .SetMethod("setPageZoomFactor", &EventSenderBindings::SetPageZoomFactor)
 520       .SetMethod("clearTouchPoints", &EventSenderBindings::ClearTouchPoints)
 521       .SetMethod("releaseTouchPoint", &EventSenderBindings::ReleaseTouchPoint)
 522       .SetMethod("updateTouchPoint", &EventSenderBindings::UpdateTouchPoint)
 523       .SetMethod("cancelTouchPoint", &EventSenderBindings::CancelTouchPoint)
 524       .SetMethod("setTouchModifier", &EventSenderBindings::SetTouchModifier)
 525       .SetMethod("setTouchCancelable", &EventSenderBindings::SetTouchCancelable)
 526       .SetMethod("dumpFilenameBeingDragged",
 527                  &EventSenderBindings::DumpFilenameBeingDragged)
 528       .SetMethod("gestureFlingCancel", &EventSenderBindings::GestureFlingCancel)
 529       .SetMethod("gestureFlingStart", &EventSenderBindings::GestureFlingStart)
 530       .SetMethod("gestureScrollFirstPoint",
 531                  &EventSenderBindings::GestureScrollFirstPoint)
 532       .SetMethod("touchStart", &EventSenderBindings::TouchStart)
 533       .SetMethod("touchMove", &EventSenderBindings::TouchMove)
 534       .SetMethod("touchMoveCausingScrollIfUncanceled",
 535                  &EventSenderBindings::TouchMoveCausingScrollIfUncanceled)
 536       .SetMethod("touchCancel", &EventSenderBindings::TouchCancel)
 537       .SetMethod("touchEnd", &EventSenderBindings::TouchEnd)
 538       .SetMethod("leapForward", &EventSenderBindings::LeapForward)
 539       .SetMethod("beginDragWithFiles", &EventSenderBindings::BeginDragWithFiles)
 540       .SetMethod("addTouchPoint", &EventSenderBindings::AddTouchPoint)
 541       .SetMethod("mouseDragBegin", &EventSenderBindings::MouseDragBegin)
 542       .SetMethod("mouseDragEnd", &EventSenderBindings::MouseDragEnd)
 543       .SetMethod("gestureScrollBegin", &EventSenderBindings::GestureScrollBegin)
 544       .SetMethod("gestureScrollEnd", &EventSenderBindings::GestureScrollEnd)
 545       .SetMethod("gestureScrollUpdate",
 546                  &EventSenderBindings::GestureScrollUpdate)
 547       .SetMethod("gesturePinchBegin", &EventSenderBindings::GesturePinchBegin)
 548       .SetMethod("gesturePinchEnd", &EventSenderBindings::GesturePinchEnd)
 549       .SetMethod("gesturePinchUpdate", &EventSenderBindings::GesturePinchUpdate)
 550       .SetMethod("gestureTap", &EventSenderBindings::GestureTap)
 551       .SetMethod("gestureTapDown", &EventSenderBindings::GestureTapDown)
 552       .SetMethod("gestureShowPress", &EventSenderBindings::GestureShowPress)
 553       .SetMethod("gestureTapCancel", &EventSenderBindings::GestureTapCancel)
 554       .SetMethod("gestureLongPress", &EventSenderBindings::GestureLongPress)
 555       .SetMethod("gestureLongTap", &EventSenderBindings::GestureLongTap)
 556       .SetMethod("gestureTwoFingerTap",
 557                  &EventSenderBindings::GestureTwoFingerTap)
 558       .SetMethod("continuousMouseScrollBy",
 559                  &EventSenderBindings::ContinuousMouseScrollBy)
 560       .SetMethod("keyDown", &EventSenderBindings::KeyDown)
 561       .SetMethod("mouseDown", &EventSenderBindings::MouseDown)
 562       .SetMethod("mouseMoveTo", &EventSenderBindings::MouseMoveTo)
 563       .SetMethod("mouseLeave", &EventSenderBindings::MouseLeave)
 564       .SetMethod("trackpadScrollBegin",
 565                  &EventSenderBindings::TrackpadScrollBegin)
 566       .SetMethod("trackpadScroll", &EventSenderBindings::TrackpadScroll)
 567       .SetMethod("trackpadScrollEnd", &EventSenderBindings::TrackpadScrollEnd)
 568       .SetMethod("mouseScrollBy", &EventSenderBindings::MouseScrollBy)
 569       .SetMethod("mouseUp", &EventSenderBindings::MouseUp)
 570       .SetMethod("mouseMomentumBegin", &EventSenderBindings::MouseMomentumBegin)
 571       .SetMethod("mouseMomentumBegin2",
 572                  &EventSenderBindings::MouseMomentumBegin2)
 573       .SetMethod("mouseMomentumScrollBy",
 574                  &EventSenderBindings::MouseMomentumScrollBy)
 575       .SetMethod("mouseMomentumEnd", &EventSenderBindings::MouseMomentumEnd)
 576       .SetMethod("scheduleAsynchronousClick",
 577                  &EventSenderBindings::ScheduleAsynchronousClick)
 578       .SetMethod("scheduleAsynchronousKeyDown",
 579                  &EventSenderBindings::ScheduleAsynchronousKeyDown)
 580       .SetProperty("forceLayoutOnEvents",
 581                    &EventSenderBindings::ForceLayoutOnEvents,
 582                    &EventSenderBindings::SetForceLayoutOnEvents)
 583       .SetProperty("dragMode", &EventSenderBindings::IsDragMode,
 584                    &EventSenderBindings::SetIsDragMode)
 585 #if defined(OS_WIN)
 586       .SetProperty("WM_KEYDOWN", &EventSenderBindings::WmKeyDown,
 587                    &EventSenderBindings::SetWmKeyDown)
 588       .SetProperty("WM_KEYUP", &EventSenderBindings::WmKeyUp,
 589                    &EventSenderBindings::SetWmKeyUp)
 590       .SetProperty("WM_CHAR", &EventSenderBindings::WmChar,
 591                    &EventSenderBindings::SetWmChar)
 592       .SetProperty("WM_DEADCHAR", &EventSenderBindings::WmDeadChar,
 593                    &EventSenderBindings::SetWmDeadChar)
 594       .SetProperty("WM_SYSKEYDOWN", &EventSenderBindings::WmSysKeyDown,
 595                    &EventSenderBindings::SetWmSysKeyDown)
 596       .SetProperty("WM_SYSKEYUP", &EventSenderBindings::WmSysKeyUp,
 597                    &EventSenderBindings::SetWmSysKeyUp)
 598       .SetProperty("WM_SYSCHAR", &EventSenderBindings::WmSysChar,
 599                    &EventSenderBindings::SetWmSysChar)
 600       .SetProperty("WM_SYSDEADCHAR", &EventSenderBindings::WmSysDeadChar,
 601                    &EventSenderBindings::SetWmSysDeadChar);
 602 #else
 603       ;
 604 #endif
 605 }
 606
 607 void EventSenderBindings::EnableDOMUIEventLogging() {
 608   if (sender_)
 609     sender_->EnableDOMUIEventLogging();
 610 }
 611
 612 void EventSenderBindings::FireKeyboardEventsToElement() {
 613   if (sender_)
 614     sender_->FireKeyboardEventsToElement();
 615 }
 616
 617 void EventSenderBindings::ClearKillRing() {
 618   if (sender_)
 619     sender_->ClearKillRing();
 620 }
 621
 622 std::vector<std::string> EventSenderBindings::ContextClick() {
 623   if (sender_)
 624     return sender_->ContextClick();
 625   return std::vector<std::string>();
 626 }
 627
 628 void EventSenderBindings::TextZoomIn() {
 629   if (sender_)
 630     sender_->TextZoomIn();
 631 }
 632
 633 void EventSenderBindings::TextZoomOut() {
 634   if (sender_)
 635     sender_->TextZoomOut();
 636 }
 637
 638 void EventSenderBindings::ZoomPageIn() {
 639   if (sender_)
 640     sender_->ZoomPageIn();
 641 }
 642
 643 void EventSenderBindings::ZoomPageOut() {
 644   if (sender_)
 645     sender_->ZoomPageOut();
 646 }
 647
 648 void EventSenderBindings::SetPageZoomFactor(double factor) {
 649   if (sender_)
 650     sender_->SetPageZoomFactor(factor);
 651 }
 652
 653 void EventSenderBindings::ClearTouchPoints() {
 654   if (sender_)
 655     sender_->ClearTouchPoints();
 656 }
 657
 658 void EventSenderBindings::ReleaseTouchPoint(unsigned index) {
 659   if (sender_)
 660     sender_->ReleaseTouchPoint(index);
 661 }
 662
 663 void EventSenderBindings::UpdateTouchPoint(unsigned index,
 664                                            double x,
 665                                            double y,
 666                                            gin::Arguments* args) {
 667   if (sender_) {
 668     sender_->UpdateTouchPoint(index, static_cast<float>(x),
 669                               static_cast<float>(y), args);
 670   }
 671 }
 672
 673 void EventSenderBindings::CancelTouchPoint(unsigned index) {
 674   if (sender_)
 675     sender_->CancelTouchPoint(index);
 676 }
 677
 678 void EventSenderBindings::SetTouchModifier(const std::string& key_name,
 679                                            bool set_mask) {
 680   if (sender_)
 681     sender_->SetTouchModifier(key_name, set_mask);
 682 }
 683
 684 void EventSenderBindings::SetTouchCancelable(bool cancelable) {
 685   if (sender_)
 686     sender_->SetTouchCancelable(cancelable);
 687 }
 688
 689 void EventSenderBindings::DumpFilenameBeingDragged() {
 690   if (sender_)
 691     sender_->DumpFilenameBeingDragged();
 692 }
 693
 694 void EventSenderBindings::GestureFlingCancel() {
 695   if (sender_)
 696     sender_->GestureFlingCancel();
 697 }
 698
 699 void EventSenderBindings::GestureFlingStart(float x,
 700                                             float y,
 701                                             float velocity_x,
 702                                             float velocity_y,
 703                                             gin::Arguments* args) {
 704   if (sender_)
 705     sender_->GestureFlingStart(x, y, velocity_x, velocity_y, args);
 706 }
 707
 708 void EventSenderBindings::GestureScrollFirstPoint(int x, int y) {
 709   if (sender_)
 710     sender_->GestureScrollFirstPoint(x, y);
 711 }
 712
 713 void EventSenderBindings::TouchStart() {
 714   if (sender_)
 715     sender_->TouchStart();
 716 }
 717
 718 void EventSenderBindings::TouchMove() {
 719   if (sender_)
 720     sender_->TouchMove();
 721 }
 722
 723 void EventSenderBindings::TouchMoveCausingScrollIfUncanceled() {
 724   if (sender_)
 725     sender_->TouchMoveCausingScrollIfUncanceled();
 726 }
 727
 728 void EventSenderBindings::TouchCancel() {
 729   if (sender_)
 730     sender_->TouchCancel();
 731 }
 732
 733 void EventSenderBindings::TouchEnd() {
 734   if (sender_)
 735     sender_->TouchEnd();
 736 }
 737
 738 void EventSenderBindings::LeapForward(int milliseconds) {
 739   if (sender_)
 740     sender_->LeapForward(milliseconds);
 741 }
 742
 743 void EventSenderBindings::BeginDragWithFiles(
 744     const std::vector<std::string>& files) {
 745   if (sender_)
 746     sender_->BeginDragWithFiles(files);
 747 }
 748
 749 void EventSenderBindings::AddTouchPoint(double x,
 750                                         double y,
 751                                         gin::Arguments* args) {
 752   if (sender_)
 753     sender_->AddTouchPoint(static_cast<float>(x), static_cast<float>(y), args);
 754 }
 755
 756 void EventSenderBindings::MouseDragBegin() {
 757   if (sender_)
 758     sender_->MouseDragBegin();
 759 }
 760
 761 void EventSenderBindings::MouseDragEnd() {
 762   if (sender_)
 763     sender_->MouseDragEnd();
 764 }
 765
 766 void EventSenderBindings::GestureScrollBegin(gin::Arguments* args) {
 767   if (sender_)
 768     sender_->GestureScrollBegin(args);
 769 }
 770
 771 void EventSenderBindings::GestureScrollEnd(gin::Arguments* args) {
 772   if (sender_)
 773     sender_->GestureScrollEnd(args);
 774 }
 775
 776 void EventSenderBindings::GestureScrollUpdate(gin::Arguments* args) {
 777   if (sender_)
 778     sender_->GestureScrollUpdate(args);
 779 }
 780
 781 void EventSenderBindings::GesturePinchBegin(gin::Arguments* args) {
 782   if (sender_)
 783     sender_->GesturePinchBegin(args);
 784 }
 785
 786 void EventSenderBindings::GesturePinchEnd(gin::Arguments* args) {
 787   if (sender_)
 788     sender_->GesturePinchEnd(args);
 789 }
 790
 791 void EventSenderBindings::GesturePinchUpdate(gin::Arguments* args) {
 792   if (sender_)
 793     sender_->GesturePinchUpdate(args);
 794 }
 795
 796 void EventSenderBindings::GestureTap(gin::Arguments* args) {
 797   if (sender_)
 798     sender_->GestureTap(args);
 799 }
 800
 801 void EventSenderBindings::GestureTapDown(gin::Arguments* args) {
 802   if (sender_)
 803     sender_->GestureTapDown(args);
 804 }
 805
 806 void EventSenderBindings::GestureShowPress(gin::Arguments* args) {
 807   if (sender_)
 808     sender_->GestureShowPress(args);
 809 }
 810
 811 void EventSenderBindings::GestureTapCancel(gin::Arguments* args) {
 812   if (sender_)
 813     sender_->GestureTapCancel(args);
 814 }
 815
 816 void EventSenderBindings::GestureLongPress(gin::Arguments* args) {
 817   if (sender_)
 818     sender_->GestureLongPress(args);
 819 }
 820
 821 void EventSenderBindings::GestureLongTap(gin::Arguments* args) {
 822   if (sender_)
 823     sender_->GestureLongTap(args);
 824 }
 825
 826 void EventSenderBindings::GestureTwoFingerTap(gin::Arguments* args) {
 827   if (sender_)
 828     sender_->GestureTwoFingerTap(args);
 829 }
 830
 831 void EventSenderBindings::ContinuousMouseScrollBy(gin::Arguments* args) {
 832   if (sender_)
 833     sender_->ContinuousMouseScrollBy(args);
 834 }
 835
 836 void EventSenderBindings::MouseMoveTo(gin::Arguments* args) {
 837   if (sender_)
 838     sender_->MouseMoveTo(args);
 839 }
 840
 841 void EventSenderBindings::MouseLeave() {
 842   if (sender_)
 843     sender_->MouseLeave();
 844 }
 845
 846 void EventSenderBindings::TrackpadScrollBegin() {
 847   if (sender_)
 848     sender_->TrackpadScrollBegin();
 849 }
 850
 851 void EventSenderBindings::TrackpadScroll(gin::Arguments* args) {
 852   if (sender_)
 853     sender_->TrackpadScroll(args);
 854 }
 855
 856 void EventSenderBindings::TrackpadScrollEnd() {
 857   if (sender_)
 858     sender_->TrackpadScrollEnd();
 859 }
 860
 861 void EventSenderBindings::MouseScrollBy(gin::Arguments* args) {
 862   if (sender_)
 863     sender_->MouseScrollBy(args);
 864 }
 865
 866 void EventSenderBindings::MouseMomentumBegin() {
 867   if (sender_)
 868     sender_->MouseMomentumBegin();
 869 }
 870
 871 void EventSenderBindings::MouseMomentumBegin2(gin::Arguments* args) {
 872   if (sender_)
 873     sender_->MouseMomentumBegin2(args);
 874 }
 875
 876 void EventSenderBindings::MouseMomentumScrollBy(gin::Arguments* args) {
 877   if (sender_)
 878     sender_->MouseMomentumScrollBy(args);
 879 }
 880
 881 void EventSenderBindings::MouseMomentumEnd() {
 882   if (sender_)
 883     sender_->MouseMomentumEnd();
 884 }
 885
 886 void EventSenderBindings::ScheduleAsynchronousClick(gin::Arguments* args) {
 887   if (!sender_)
 888     return;
 889
 890   int button_number = 0;
 891   int modifiers = 0;
 892   if (!args->PeekNext().IsEmpty()) {
 893     args->GetNext(&button_number);
 894     if (!args->PeekNext().IsEmpty())
 895       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
 896   }
 897   sender_->ScheduleAsynchronousClick(button_number, modifiers);
 898 }
 899
 900 void EventSenderBindings::ScheduleAsynchronousKeyDown(gin::Arguments* args) {
 901   if (!sender_)
 902     return;
 903
 904   std::string code_str;
 905   int modifiers = 0;
 906   int location = DOMKeyLocationStandard;
 907   args->GetNext(&code_str);
 908   if (!args->PeekNext().IsEmpty()) {
 909     v8::Local<v8::Value> value;
 910     args->GetNext(&value);
 911     modifiers = GetKeyModifiersFromV8(args->isolate(), value);
 912     if (!args->PeekNext().IsEmpty())
 913       args->GetNext(&location);
 914   }
 915   sender_->ScheduleAsynchronousKeyDown(code_str, modifiers,
 916                                        static_cast<KeyLocationCode>(location));
 917 }
 918
 919 void EventSenderBindings::MouseDown(gin::Arguments* args) {
 920   if (!sender_)
 921     return;
 922
 923   int button_number = 0;
 924   int modifiers = 0;
 925   if (!args->PeekNext().IsEmpty()) {
 926     args->GetNext(&button_number);
 927     if (!args->PeekNext().IsEmpty())
 928       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
 929   }
 930   sender_->MouseDown(button_number, modifiers);
 931 }
 932
 933 void EventSenderBindings::MouseUp(gin::Arguments* args) {
 934   if (!sender_)
 935     return;
 936
 937   int button_number = 0;
 938   int modifiers = 0;
 939   if (!args->PeekNext().IsEmpty()) {
 940     args->GetNext(&button_number);
 941     if (!args->PeekNext().IsEmpty())
 942       modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
 943   }
 944   sender_->MouseUp(button_number, modifiers);
 945 }
 946
 947 void EventSenderBindings::KeyDown(gin::Arguments* args) {
 948   if (!sender_)
 949     return;
 950
 951   std::string code_str;
 952   int modifiers = 0;
 953   int location = DOMKeyLocationStandard;
 954   args->GetNext(&code_str);
 955   if (!args->PeekNext().IsEmpty()) {
 956     v8::Local<v8::Value> value;
 957     args->GetNext(&value);
 958     modifiers = GetKeyModifiersFromV8(args->isolate(), value);
 959     if (!args->PeekNext().IsEmpty())
 960       args->GetNext(&location);
 961   }
 962   sender_->KeyDown(code_str, modifiers, static_cast<KeyLocationCode>(location));
 963 }
 964
 965 bool EventSenderBindings::ForceLayoutOnEvents() const {
 966   if (sender_)
 967     return sender_->force_layout_on_events();
 968   return false;
 969 }
 970
 971 void EventSenderBindings::SetForceLayoutOnEvents(bool force) {
 972   if (sender_)
 973     sender_->set_force_layout_on_events(force);
 974 }
 975
 976 bool EventSenderBindings::IsDragMode() const {
 977   if (sender_)
 978     return sender_->is_drag_mode();
 979   return true;
 980 }
 981
 982 void EventSenderBindings::SetIsDragMode(bool drag_mode) {
 983   if (sender_)
 984     sender_->set_is_drag_mode(drag_mode);
 985 }
 986
 987 #if defined(OS_WIN)
 988 int EventSenderBindings::WmKeyDown() const {
 989   if (sender_)
 990     return sender_->wm_key_down();
 991   return 0;
 992 }
 993
 994 void EventSenderBindings::SetWmKeyDown(int key_down) {
 995   if (sender_)
 996     sender_->set_wm_key_down(key_down);
 997 }
 998
 999 int EventSenderBindings::WmKeyUp() const {
1000   if (sender_)
1001     return sender_->wm_key_up();
1002   return 0;
1003 }
1004
1005 void EventSenderBindings::SetWmKeyUp(int key_up) {
1006   if (sender_)
1007     sender_->set_wm_key_up(key_up);
1008 }
1009
1010 int EventSenderBindings::WmChar() const {
1011   if (sender_)
1012     return sender_->wm_char();
1013   return 0;
1014 }
1015
1016 void EventSenderBindings::SetWmChar(int wm_char) {
1017   if (sender_)
1018     sender_->set_wm_char(wm_char);
1019 }
1020
1021 int EventSenderBindings::WmDeadChar() const {
1022   if (sender_)
1023     return sender_->wm_dead_char();
1024   return 0;
1025 }
1026
1027 void EventSenderBindings::SetWmDeadChar(int dead_char) {
1028   if (sender_)
1029     sender_->set_wm_dead_char(dead_char);
1030 }
1031
1032 int EventSenderBindings::WmSysKeyDown() const {
1033   if (sender_)
1034     return sender_->wm_sys_key_down();
1035   return 0;
1036 }
1037
1038 void EventSenderBindings::SetWmSysKeyDown(int key_down) {
1039   if (sender_)
1040     sender_->set_wm_sys_key_down(key_down);
1041 }
1042
1043 int EventSenderBindings::WmSysKeyUp() const {
1044   if (sender_)
1045     return sender_->wm_sys_key_up();
1046   return 0;
1047 }
1048
1049 void EventSenderBindings::SetWmSysKeyUp(int key_up) {
1050   if (sender_)
1051     sender_->set_wm_sys_key_up(key_up);
1052 }
1053
1054 int EventSenderBindings::WmSysChar() const {
1055   if (sender_)
1056     return sender_->wm_sys_char();
1057   return 0;
1058 }
1059
1060 void EventSenderBindings::SetWmSysChar(int sys_char) {
1061   if (sender_)
1062     sender_->set_wm_sys_char(sys_char);
1063 }
1064
1065 int EventSenderBindings::WmSysDeadChar() const {
1066   if (sender_)
1067     return sender_->wm_sys_dead_char();
1068   return 0;
1069 }
1070
1071 void EventSenderBindings::SetWmSysDeadChar(int sys_dead_char) {
1072   if (sender_)
1073     sender_->set_wm_sys_dead_char(sys_dead_char);
1074 }
1075 #endif
1076
1077 // EventSender -----------------------------------------------------------------
1078
1079 WebMouseEvent::Button EventSender::pressed_button_ = WebMouseEvent::ButtonNone;
1080 int EventSender::modifiers_ = 0;
1081
1082 WebPoint EventSender::last_mouse_pos_;
1083
1084 WebMouseEvent::Button EventSender::last_button_type_ =
1085     WebMouseEvent::ButtonNone;
1086
1087 EventSender::SavedEvent::SavedEvent()
1088     : type(TYPE_UNSPECIFIED),
1089       button_type(WebMouseEvent::ButtonNone),
1090       milliseconds(0),
1091       modifiers(0) {}
1092
1093 EventSender::EventSender(TestInterfaces* interfaces)
1094     :
1095 #if defined(OS_WIN)
1096       wm_key_down_(0),
1097       wm_key_up_(0),
1098       wm_char_(0),
1099       wm_dead_char_(0),
1100       wm_sys_key_down_(0),
1101       wm_sys_key_up_(0),
1102       wm_sys_char_(0),
1103       wm_sys_dead_char_(0),
1104 #endif
1105       interfaces_(interfaces),
1106       delegate_(NULL),
1107       view_(NULL),
1108       force_layout_on_events_(false),
1109       is_drag_mode_(true),
1110       touch_modifiers_(0),
1111       touch_cancelable_(true),
1112       replaying_saved_events_(false),
1113       current_drag_effects_allowed_(blink::WebDragOperationNone),
1114       last_click_time_sec_(0),
1115       current_drag_effect_(blink::WebDragOperationNone),
1116       time_offset_ms_(0),
1117       click_count_(0),
1118       weak_factory_(this) {
1119 }
1120
1121 EventSender::~EventSender() {}
1122
1123 void EventSender::Reset() {
1124   DCHECK(current_drag_data_.isNull());
1125   current_drag_data_.reset();
1126   current_drag_effect_ = blink::WebDragOperationNone;
1127   current_drag_effects_allowed_ = blink::WebDragOperationNone;
1128   if (view_ && pressed_button_ != WebMouseEvent::ButtonNone)
1129     view_->mouseCaptureLost();
1130   pressed_button_ = WebMouseEvent::ButtonNone;
1131   is_drag_mode_ = true;
1132   force_layout_on_events_ = true;
1133
1134 #if defined(OS_WIN)
1135   wm_key_down_ = WM_KEYDOWN;
1136   wm_key_up_ = WM_KEYUP;
1137   wm_char_ = WM_CHAR;
1138   wm_dead_char_ = WM_DEADCHAR;
1139   wm_sys_key_down_ = WM_SYSKEYDOWN;
1140   wm_sys_key_up_ = WM_SYSKEYUP;
1141   wm_sys_char_ = WM_SYSCHAR;
1142   wm_sys_dead_char_ = WM_SYSDEADCHAR;
1143 #endif
1144
1145   last_mouse_pos_ = WebPoint(0, 0);
1146   last_click_time_sec_ = 0;
1147   last_click_pos_ = WebPoint(0, 0);
1148   last_button_type_ = WebMouseEvent::ButtonNone;
1149   touch_points_.clear();
1150   last_context_menu_data_.reset();
1151   task_list_.RevokeAll();
1152   current_gesture_location_ = WebPoint(0, 0);
1153   mouse_event_queue_.clear();
1154
1155   time_offset_ms_ = 0;
1156   click_count_ = 0;
1157
1158   touch_modifiers_ = 0;
1159   touch_cancelable_ = true;
1160   touch_points_.clear();
1161 }
1162
1163 void EventSender::Install(WebFrame* frame) {
1164   EventSenderBindings::Install(weak_factory_.GetWeakPtr(), frame);
1165 }
1166
1167 void EventSender::SetDelegate(WebTestDelegate* delegate) {
1168   delegate_ = delegate;
1169 }
1170
1171 void EventSender::SetWebView(WebView* view) {
1172   view_ = view;
1173 }
1174
1175 void EventSender::SetContextMenuData(const WebContextMenuData& data) {
1176   last_context_menu_data_.reset(new WebContextMenuData(data));
1177 }
1178
1179 void EventSender::DoDragDrop(const WebDragData& drag_data,
1180                               WebDragOperationsMask mask) {
1181   WebMouseEvent event;
1182   InitMouseEvent(WebInputEvent::MouseDown,
1183                  pressed_button_,
1184                  last_mouse_pos_,
1185                  GetCurrentEventTimeSec(),
1186                  click_count_,
1187                  modifiers_,
1188                  &event);
1189   WebPoint client_point(event.x, event.y);
1190   WebPoint screen_point(event.globalX, event.globalY);
1191   current_drag_data_ = drag_data;
1192   current_drag_effects_allowed_ = mask;
1193   current_drag_effect_ = view_->dragTargetDragEnter(
1194       drag_data,
1195       client_point,
1196       screen_point,
1197       current_drag_effects_allowed_,
1198       modifiers_);
1199
1200   // Finish processing events.
1201   ReplaySavedEvents();
1202 }
1203
1204 void EventSender::MouseDown(int button_number, int modifiers) {
1205   if (force_layout_on_events_)
1206     view_->layout();
1207
1208   DCHECK_NE(-1, button_number);
1209
1210   WebMouseEvent::Button button_type =
1211       GetButtonTypeFromButtonNumber(button_number);
1212
1213   UpdateClickCountForButton(button_type);
1214
1215   pressed_button_ = button_type;
1216   modifiers_ = modifiers;
1217
1218   WebMouseEvent event;
1219   InitMouseEvent(WebInputEvent::MouseDown,
1220                  button_type,
1221                  last_mouse_pos_,
1222                  GetCurrentEventTimeSec(),
1223                  click_count_,
1224                  modifiers,
1225                  &event);
1226   HandleInputEventOnViewOrPopup(event);
1227 }
1228
1229 void EventSender::MouseUp(int button_number, int modifiers) {
1230   if (force_layout_on_events_)
1231     view_->layout();
1232
1233   DCHECK_NE(-1, button_number);
1234
1235   WebMouseEvent::Button button_type =
1236       GetButtonTypeFromButtonNumber(button_number);
1237
1238   if (is_drag_mode_ && !replaying_saved_events_) {
1239     SavedEvent saved_event;
1240     saved_event.type = SavedEvent::TYPE_MOUSE_UP;
1241     saved_event.button_type = button_type;
1242     saved_event.modifiers = modifiers;
1243     mouse_event_queue_.push_back(saved_event);
1244     ReplaySavedEvents();
1245   } else {
1246     WebMouseEvent event;
1247     InitMouseEvent(WebInputEvent::MouseUp,
1248                    button_type,
1249                    last_mouse_pos_,
1250                    GetCurrentEventTimeSec(),
1251                    click_count_,
1252                    modifiers,
1253                    &event);
1254     DoMouseUp(event);
1255   }
1256 }
1257
1258 void EventSender::KeyDown(const std::string& code_str,
1259                           int modifiers,
1260                           KeyLocationCode location) {
1261   // FIXME: I'm not exactly sure how we should convert the string to a key
1262   // event. This seems to work in the cases I tested.
1263   // FIXME: Should we also generate a KEY_UP?
1264
1265   bool generate_char = false;
1266
1267   // Convert \n -> VK_RETURN. Some layout tests use \n to mean "Enter", when
1268   // Windows uses \r for "Enter".
1269   int code = 0;
1270   int text = 0;
1271   bool needs_shift_key_modifier = false;
1272   std::string domString;
1273
1274   if ("\n" == code_str) {
1275     generate_char = true;
1276     text = code = ui::VKEY_RETURN;
1277     domString.assign("Enter");
1278   } else if ("rightArrow" == code_str) {
1279     code = ui::VKEY_RIGHT;
1280     domString.assign("ArrowRight");
1281   } else if ("downArrow" == code_str) {
1282     code = ui::VKEY_DOWN;
1283     domString.assign("ArrowDown");
1284   } else if ("leftArrow" == code_str) {
1285     code = ui::VKEY_LEFT;
1286     domString.assign("ArrowLeft");
1287   } else if ("upArrow" == code_str) {
1288     code = ui::VKEY_UP;
1289     domString.assign("ArrowUp");
1290   } else if ("insert" == code_str) {
1291     code = ui::VKEY_INSERT;
1292     domString.assign("Insert");
1293   } else if ("delete" == code_str) {
1294     code = ui::VKEY_DELETE;
1295     domString.assign("Delete");
1296   } else if ("pageUp" == code_str) {
1297     code = ui::VKEY_PRIOR;
1298     domString.assign("PageUp");
1299   } else if ("pageDown" == code_str) {
1300     code = ui::VKEY_NEXT;
1301     domString.assign("PageDown");
1302   } else if ("home" == code_str) {
1303     code = ui::VKEY_HOME;
1304     domString.assign("Home");
1305   } else if ("end" == code_str) {
1306     code = ui::VKEY_END;
1307     domString.assign("End");
1308   } else if ("printScreen" == code_str) {
1309     code = ui::VKEY_SNAPSHOT;
1310     domString.assign("PrintScreen");
1311   } else if ("menu" == code_str) {
1312     code = ui::VKEY_APPS;
1313     domString.assign("ContextMenu");
1314   } else if ("leftControl" == code_str) {
1315     code = ui::VKEY_LCONTROL;
1316     domString.assign("ControlLeft");
1317   } else if ("rightControl" == code_str) {
1318     code = ui::VKEY_RCONTROL;
1319     domString.assign("ControlRight");
1320   } else if ("leftShift" == code_str) {
1321     code = ui::VKEY_LSHIFT;
1322     domString.assign("ShiftLeft");
1323   } else if ("rightShift" == code_str) {
1324     code = ui::VKEY_RSHIFT;
1325     domString.assign("ShiftRight");
1326   } else if ("leftAlt" == code_str) {
1327     code = ui::VKEY_LMENU;
1328     domString.assign("AltLeft");
1329   } else if ("rightAlt" == code_str) {
1330     code = ui::VKEY_RMENU;
1331     domString.assign("AltRight");
1332   } else if ("numLock" == code_str) {
1333     code = ui::VKEY_NUMLOCK;
1334     domString.assign("NumLock");
1335   } else if ("backspace" == code_str) {
1336     code = ui::VKEY_BACK;
1337     domString.assign("Backspace");
1338   } else if ("escape" == code_str) {
1339     code = ui::VKEY_ESCAPE;
1340     domString.assign("Escape");
1341   } else {
1342     // Compare the input string with the function-key names defined by the
1343     // DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key
1344     // name, set its key code.
1345     for (int i = 1; i <= 24; ++i) {
1346       std::string function_key_name = base::StringPrintf("F%d", i);
1347       if (function_key_name == code_str) {
1348         code = ui::VKEY_F1 + (i - 1);
1349         domString = function_key_name;
1350         break;
1351       }
1352     }
1353     if (!code) {
1354       WebString web_code_str =
1355           WebString::fromUTF8(code_str.data(), code_str.size());
1356       if (web_code_str.length() != 1u) {
1357         v8::Isolate* isolate = blink::mainThreadIsolate();
1358         isolate->ThrowException(v8::Exception::TypeError(
1359             gin::StringToV8(isolate, "Invalid web code.")));
1360         return;
1361       }
1362       text = code = web_code_str.at(0);
1363       needs_shift_key_modifier = NeedsShiftModifier(code);
1364       if ((code & 0xFF) >= 'a' && (code & 0xFF) <= 'z')
1365         code -= 'a' - 'A';
1366       if ((code >= 'A' && code <= 'Z') || (code >= 'a' && code <= 'z')) {
1367         domString.assign("Key");
1368         domString.push_back(
1369             base::ToUpperASCII(static_cast<base::char16>(code)));
1370       } else if (code >= '0' && code <= '9') {
1371         domString.assign("Digit");
1372         domString.push_back(code);
1373       } else if (code == ' ') {
1374         domString.assign("Space");
1375       } else if (code == 9) {
1376         domString.assign("Tab");
1377       }
1378       generate_char = true;
1379     }
1380
1381     if ("(" == code_str) {
1382       code = '9';
1383       needs_shift_key_modifier = true;
1384     }
1385   }
1386
1387   // For one generated keyboard event, we need to generate a keyDown/keyUp
1388   // pair;
1389   // On Windows, we might also need to generate a char event to mimic the
1390   // Windows event flow; on other platforms we create a merged event and test
1391   // the event flow that that platform provides.
1392   WebKeyboardEvent event_down;
1393   event_down.type = WebInputEvent::RawKeyDown;
1394   event_down.modifiers = modifiers;
1395   event_down.windowsKeyCode = code;
1396   event_down.domCode = static_cast<int>(
1397       ui::KeycodeConverter::CodeStringToDomCode(domString.c_str()));
1398
1399   if (generate_char) {
1400     event_down.text[0] = text;
1401     event_down.unmodifiedText[0] = text;
1402   }
1403
1404   event_down.setKeyIdentifierFromWindowsKeyCode();
1405
1406   if (event_down.modifiers != 0)
1407     event_down.isSystemKey = IsSystemKeyEvent(event_down);
1408
1409   if (needs_shift_key_modifier)
1410     event_down.modifiers |= WebInputEvent::ShiftKey;
1411
1412   // See if KeyLocation argument is given.
1413   if (location == DOMKeyLocationNumpad)
1414     event_down.modifiers |= WebInputEvent::IsKeyPad;
1415
1416   WebKeyboardEvent event_up;
1417   event_up = event_down;
1418   event_up.type = WebInputEvent::KeyUp;
1419   // EventSender.m forces a layout here, with at least one
1420   // test (fast/forms/focus-control-to-page.html) relying on this.
1421   if (force_layout_on_events_)
1422     view_->layout();
1423
1424   // In the browser, if a keyboard event corresponds to an editor command,
1425   // the command will be dispatched to the renderer just before dispatching
1426   // the keyboard event, and then it will be executed in the
1427   // RenderView::handleCurrentKeyboardEvent() method.
1428   // We just simulate the same behavior here.
1429   std::string edit_command;
1430   if (GetEditCommand(event_down, &edit_command))
1431     delegate_->SetEditCommand(edit_command, "");
1432
1433   HandleInputEventOnViewOrPopup(event_down);
1434
1435   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
1436     WebMouseEvent event;
1437     InitMouseEvent(WebInputEvent::MouseDown,
1438                    pressed_button_,
1439                    last_mouse_pos_,
1440                    GetCurrentEventTimeSec(),
1441                    click_count_,
1442                    0,
1443                    &event);
1444     FinishDragAndDrop(event, blink::WebDragOperationNone);
1445   }
1446
1447   delegate_->ClearEditCommand();
1448
1449   if (generate_char) {
1450     WebKeyboardEvent event_char = event_up;
1451     event_char.type = WebInputEvent::Char;
1452     // keyIdentifier is an empty string, unless the Enter key was pressed.
1453     // This behavior is not standard (keyIdentifier itself is not even a
1454     // standard any more), but it matches the actual behavior in Blink.
1455     if (code != ui::VKEY_RETURN)
1456       event_char.keyIdentifier[0] = '\0';
1457     HandleInputEventOnViewOrPopup(event_char);
1458   }
1459
1460   HandleInputEventOnViewOrPopup(event_up);
1461 }
1462
1463 void EventSender::EnableDOMUIEventLogging() {}
1464
1465 void EventSender::FireKeyboardEventsToElement() {}
1466
1467 void EventSender::ClearKillRing() {}
1468
1469 std::vector<std::string> EventSender::ContextClick() {
1470   if (force_layout_on_events_) {
1471     view_->layout();
1472   }
1473
1474   UpdateClickCountForButton(WebMouseEvent::ButtonRight);
1475
1476   // Clears last context menu data because we need to know if the context menu
1477   // be requested after following mouse events.
1478   last_context_menu_data_.reset();
1479
1480   // Generate right mouse down and up.
1481   WebMouseEvent event;
1482   // This is a hack to work around only allowing a single pressed button since
1483   // we want to test the case where both the left and right mouse buttons are
1484   // pressed.
1485   if (pressed_button_ == WebMouseEvent::ButtonNone) {
1486     pressed_button_ = WebMouseEvent::ButtonRight;
1487   }
1488   InitMouseEvent(WebInputEvent::MouseDown,
1489                  WebMouseEvent::ButtonRight,
1490                  last_mouse_pos_,
1491                  GetCurrentEventTimeSec(),
1492                  click_count_,
1493                  0,
1494                  &event);
1495   HandleInputEventOnViewOrPopup(event);
1496
1497 #if defined(OS_WIN)
1498   InitMouseEvent(WebInputEvent::MouseUp,
1499                  WebMouseEvent::ButtonRight,
1500                  last_mouse_pos_,
1501                  GetCurrentEventTimeSec(),
1502                  click_count_,
1503                  0,
1504                  &event);
1505   HandleInputEventOnViewOrPopup(event);
1506
1507   pressed_button_= WebMouseEvent::ButtonNone;
1508 #endif
1509
1510   std::vector<std::string> menu_items =
1511       MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate_);
1512   last_context_menu_data_.reset();
1513   return menu_items;
1514 }
1515
1516 void EventSender::TextZoomIn() {
1517   view_->setTextZoomFactor(view_->textZoomFactor() * 1.2f);
1518 }
1519
1520 void EventSender::TextZoomOut() {
1521   view_->setTextZoomFactor(view_->textZoomFactor() / 1.2f);
1522 }
1523
1524 void EventSender::ZoomPageIn() {
1525   const std::vector<WebTestProxyBase*>& window_list =
1526       interfaces_->GetWindowList();
1527
1528   for (size_t i = 0; i < window_list.size(); ++i) {
1529     window_list.at(i)->GetWebView()->setZoomLevel(
1530         window_list.at(i)->GetWebView()->zoomLevel() + 1);
1531   }
1532 }
1533
1534 void EventSender::ZoomPageOut() {
1535   const std::vector<WebTestProxyBase*>& window_list =
1536       interfaces_->GetWindowList();
1537
1538   for (size_t i = 0; i < window_list.size(); ++i) {
1539     window_list.at(i)->GetWebView()->setZoomLevel(
1540         window_list.at(i)->GetWebView()->zoomLevel() - 1);
1541   }
1542 }
1543
1544 void EventSender::SetPageZoomFactor(double zoom_factor) {
1545   const std::vector<WebTestProxyBase*>& window_list =
1546       interfaces_->GetWindowList();
1547
1548   for (size_t i = 0; i < window_list.size(); ++i) {
1549     window_list.at(i)->GetWebView()->setZoomLevel(
1550         std::log(zoom_factor) / std::log(1.2));
1551   }
1552 }
1553
1554 void EventSender::ClearTouchPoints() {
1555   touch_points_.clear();
1556 }
1557
1558 void EventSender::ThrowTouchPointError() {
1559   v8::Isolate* isolate = blink::mainThreadIsolate();
1560   isolate->ThrowException(v8::Exception::TypeError(
1561       gin::StringToV8(isolate, "Invalid touch point.")));
1562 }
1563
1564 void EventSender::ReleaseTouchPoint(unsigned index) {
1565   if (index >= touch_points_.size()) {
1566     ThrowTouchPointError();
1567     return;
1568   }
1569
1570   WebTouchPoint* touch_point = &touch_points_[index];
1571   touch_point->state = WebTouchPoint::StateReleased;
1572 }
1573
1574 void EventSender::UpdateTouchPoint(unsigned index,
1575                                    float x,
1576                                    float y,
1577                                    gin::Arguments* args) {
1578   if (index >= touch_points_.size()) {
1579     ThrowTouchPointError();
1580     return;
1581   }
1582
1583   WebTouchPoint* touch_point = &touch_points_[index];
1584   touch_point->state = WebTouchPoint::StateMoved;
1585   touch_point->position = WebFloatPoint(x, y);
1586   touch_point->screenPosition = touch_point->position;
1587
1588   InitPointerProperties(args, touch_point, &touch_point->radiusX,
1589                         &touch_point->radiusY);
1590 }
1591
1592 void EventSender::CancelTouchPoint(unsigned index) {
1593   if (index >= touch_points_.size()) {
1594     ThrowTouchPointError();
1595     return;
1596   }
1597
1598   WebTouchPoint* touch_point = &touch_points_[index];
1599   touch_point->state = WebTouchPoint::StateCancelled;
1600 }
1601
1602 void EventSender::SetTouchModifier(const std::string& key_name,
1603                                     bool set_mask) {
1604   int mask = 0;
1605   if (key_name == "shift")
1606     mask = WebInputEvent::ShiftKey;
1607   else if (key_name == "alt")
1608     mask = WebInputEvent::AltKey;
1609   else if (key_name == "ctrl")
1610     mask = WebInputEvent::ControlKey;
1611   else if (key_name == "meta")
1612     mask = WebInputEvent::MetaKey;
1613
1614   if (set_mask)
1615     touch_modifiers_ |= mask;
1616   else
1617     touch_modifiers_ &= ~mask;
1618 }
1619
1620 void EventSender::SetTouchCancelable(bool cancelable) {
1621   touch_cancelable_ = cancelable;
1622 }
1623
1624 void EventSender::DumpFilenameBeingDragged() {
1625   if (current_drag_data_.isNull())
1626     return;
1627
1628   WebString filename;
1629   WebVector<WebDragData::Item> items = current_drag_data_.items();
1630   for (size_t i = 0; i < items.size(); ++i) {
1631     if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
1632       filename = items[i].title;
1633       break;
1634     }
1635   }
1636   delegate_->PrintMessage(std::string("Filename being dragged: ") +
1637                           filename.utf8().data() + "\n");
1638 }
1639
1640 void EventSender::GestureFlingCancel() {
1641   WebGestureEvent event;
1642   event.type = WebInputEvent::GestureFlingCancel;
1643   event.timeStampSeconds = GetCurrentEventTimeSec();
1644
1645   if (force_layout_on_events_)
1646     view_->layout();
1647
1648   HandleInputEventOnViewOrPopup(event);
1649 }
1650
1651 void EventSender::GestureFlingStart(float x,
1652                                     float y,
1653                                     float velocity_x,
1654                                     float velocity_y,
1655                                     gin::Arguments* args) {
1656   WebGestureEvent event;
1657   event.type = WebInputEvent::GestureFlingStart;
1658
1659   std::string device_string;
1660   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString())
1661     args->GetNext(&device_string);
1662
1663   if (device_string == kSourceDeviceStringTouchpad) {
1664     event.sourceDevice = blink::WebGestureDeviceTouchpad;
1665   } else if (device_string == kSourceDeviceStringTouchscreen) {
1666     event.sourceDevice = blink::WebGestureDeviceTouchscreen;
1667   } else {
1668     args->ThrowError();
1669     return;
1670   }
1671
1672   event.x = x;
1673   event.y = y;
1674   event.globalX = event.x;
1675   event.globalY = event.y;
1676
1677   event.data.flingStart.velocityX = velocity_x;
1678   event.data.flingStart.velocityY = velocity_y;
1679   event.timeStampSeconds = GetCurrentEventTimeSec();
1680
1681   if (force_layout_on_events_)
1682     view_->layout();
1683
1684   HandleInputEventOnViewOrPopup(event);
1685 }
1686
1687 void EventSender::GestureScrollFirstPoint(int x, int y) {
1688   current_gesture_location_ = WebPoint(x, y);
1689 }
1690
1691 void EventSender::TouchStart() {
1692   SendCurrentTouchEvent(WebInputEvent::TouchStart, false);
1693 }
1694
1695 void EventSender::TouchMove() {
1696   SendCurrentTouchEvent(WebInputEvent::TouchMove, false);
1697 }
1698
1699 void EventSender::TouchMoveCausingScrollIfUncanceled() {
1700   SendCurrentTouchEvent(WebInputEvent::TouchMove, true);
1701 }
1702
1703 void EventSender::TouchCancel() {
1704   SendCurrentTouchEvent(WebInputEvent::TouchCancel, false);
1705 }
1706
1707 void EventSender::TouchEnd() {
1708   SendCurrentTouchEvent(WebInputEvent::TouchEnd, false);
1709 }
1710
1711 void EventSender::LeapForward(int milliseconds) {
1712   if (is_drag_mode_ && pressed_button_ == WebMouseEvent::ButtonLeft &&
1713       !replaying_saved_events_) {
1714     SavedEvent saved_event;
1715     saved_event.type = SavedEvent::TYPE_LEAP_FORWARD;
1716     saved_event.milliseconds = milliseconds;
1717     mouse_event_queue_.push_back(saved_event);
1718   } else {
1719     DoLeapForward(milliseconds);
1720   }
1721 }
1722
1723 void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) {
1724   current_drag_data_.initialize();
1725   WebVector<WebString> absolute_filenames(files.size());
1726   for (size_t i = 0; i < files.size(); ++i) {
1727     WebDragData::Item item;
1728     item.storageType = WebDragData::Item::StorageTypeFilename;
1729     item.filenameData = delegate_->GetAbsoluteWebStringFromUTF8Path(files[i]);
1730     current_drag_data_.addItem(item);
1731     absolute_filenames[i] = item.filenameData;
1732   }
1733   current_drag_data_.setFilesystemId(
1734       delegate_->RegisterIsolatedFileSystem(absolute_filenames));
1735   current_drag_effects_allowed_ = blink::WebDragOperationCopy;
1736
1737   // Provide a drag source.
1738   view_->dragTargetDragEnter(current_drag_data_,
1739                              last_mouse_pos_,
1740                              last_mouse_pos_,
1741                              current_drag_effects_allowed_,
1742                              0);
1743   // |is_drag_mode_| saves events and then replays them later. We don't
1744   // need/want that.
1745   is_drag_mode_ = false;
1746
1747   // Make the rest of eventSender think a drag is in progress.
1748   pressed_button_ = WebMouseEvent::ButtonLeft;
1749 }
1750
1751 void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
1752   WebTouchPoint touch_point;
1753   touch_point.state = WebTouchPoint::StatePressed;
1754   touch_point.position = WebFloatPoint(x, y);
1755   touch_point.screenPosition = touch_point.position;
1756
1757   // TODO(e_hakkinen): Make this algorithm more robust so that it handles
1758   // touch points which are not sorted by their ids, too.
1759   int lowest_id = 0;
1760   for (size_t i = 0; i < touch_points_.size(); i++) {
1761     if (touch_points_[i].id == lowest_id)
1762       lowest_id++;
1763   }
1764   touch_point.id = lowest_id;
1765
1766   InitPointerProperties(args, &touch_point, &touch_point.radiusX,
1767                         &touch_point.radiusY);
1768
1769   touch_points_.push_back(touch_point);
1770 }
1771
1772 void EventSender::MouseDragBegin() {
1773   WebMouseWheelEvent event;
1774   InitMouseEvent(WebInputEvent::MouseWheel,
1775                  WebMouseEvent::ButtonNone,
1776                  last_mouse_pos_,
1777                  GetCurrentEventTimeSec(),
1778                  click_count_,
1779                  0,
1780                  &event);
1781   event.phase = WebMouseWheelEvent::PhaseBegan;
1782   event.hasPreciseScrollingDeltas = true;
1783   HandleInputEventOnViewOrPopup(event);
1784 }
1785
1786 void EventSender::MouseDragEnd() {
1787   WebMouseWheelEvent event;
1788   InitMouseEvent(WebInputEvent::MouseWheel,
1789                  WebMouseEvent::ButtonNone,
1790                  last_mouse_pos_,
1791                  GetCurrentEventTimeSec(),
1792                  click_count_,
1793                  0,
1794                  &event);
1795   event.phase = WebMouseWheelEvent::PhaseEnded;
1796   event.hasPreciseScrollingDeltas = true;
1797   HandleInputEventOnViewOrPopup(event);
1798 }
1799
1800 void EventSender::GestureScrollBegin(gin::Arguments* args) {
1801   GestureEvent(WebInputEvent::GestureScrollBegin, args);
1802 }
1803
1804 void EventSender::GestureScrollEnd(gin::Arguments* args) {
1805   GestureEvent(WebInputEvent::GestureScrollEnd, args);
1806 }
1807
1808 void EventSender::GestureScrollUpdate(gin::Arguments* args) {
1809   GestureEvent(WebInputEvent::GestureScrollUpdate, args);
1810 }
1811
1812 void EventSender::GesturePinchBegin(gin::Arguments* args) {
1813   GestureEvent(WebInputEvent::GesturePinchBegin, args);
1814 }
1815
1816 void EventSender::GesturePinchEnd(gin::Arguments* args) {
1817   GestureEvent(WebInputEvent::GesturePinchEnd, args);
1818 }
1819
1820 void EventSender::GesturePinchUpdate(gin::Arguments* args) {
1821   GestureEvent(WebInputEvent::GesturePinchUpdate, args);
1822 }
1823
1824 void EventSender::GestureTap(gin::Arguments* args) {
1825   GestureEvent(WebInputEvent::GestureTap, args);
1826 }
1827
1828 void EventSender::GestureTapDown(gin::Arguments* args) {
1829   GestureEvent(WebInputEvent::GestureTapDown, args);
1830 }
1831
1832 void EventSender::GestureShowPress(gin::Arguments* args) {
1833   GestureEvent(WebInputEvent::GestureShowPress, args);
1834 }
1835
1836 void EventSender::GestureTapCancel(gin::Arguments* args) {
1837   GestureEvent(WebInputEvent::GestureTapCancel, args);
1838 }
1839
1840 void EventSender::GestureLongPress(gin::Arguments* args) {
1841   GestureEvent(WebInputEvent::GestureLongPress, args);
1842 }
1843
1844 void EventSender::GestureLongTap(gin::Arguments* args) {
1845   GestureEvent(WebInputEvent::GestureLongTap, args);
1846 }
1847
1848 void EventSender::GestureTwoFingerTap(gin::Arguments* args) {
1849   GestureEvent(WebInputEvent::GestureTwoFingerTap, args);
1850 }
1851
1852 void EventSender::ContinuousMouseScrollBy(gin::Arguments* args) {
1853   WebMouseWheelEvent event;
1854   InitMouseWheelEvent(args, true, &event);
1855   HandleInputEventOnViewOrPopup(event);
1856 }
1857
1858 void EventSender::MouseMoveTo(gin::Arguments* args) {
1859   if (force_layout_on_events_)
1860     view_->layout();
1861
1862   double x;
1863   double y;
1864   if (!args->GetNext(&x) || !args->GetNext(&y)) {
1865     args->ThrowError();
1866     return;
1867   }
1868   WebPoint mouse_pos(static_cast<int>(x), static_cast<int>(y));
1869
1870   int modifiers = 0;
1871   if (!args->PeekNext().IsEmpty())
1872     modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
1873
1874   if (is_drag_mode_ && pressed_button_ == WebMouseEvent::ButtonLeft &&
1875       !replaying_saved_events_) {
1876     SavedEvent saved_event;
1877     saved_event.type = SavedEvent::TYPE_MOUSE_MOVE;
1878     saved_event.pos = mouse_pos;
1879     saved_event.modifiers = modifiers;
1880     mouse_event_queue_.push_back(saved_event);
1881   } else {
1882     WebMouseEvent event;
1883     InitMouseEvent(WebInputEvent::MouseMove,
1884                    pressed_button_,
1885                    mouse_pos,
1886                    GetCurrentEventTimeSec(),
1887                    click_count_,
1888                    modifiers,
1889                    &event);
1890     DoMouseMove(event);
1891   }
1892 }
1893
1894 void EventSender::MouseLeave() {
1895   if (force_layout_on_events_)
1896     view_->layout();
1897
1898   WebMouseEvent event;
1899   InitMouseEvent(WebInputEvent::MouseLeave,
1900                  WebMouseEvent::ButtonNone,
1901                  last_mouse_pos_,
1902                  GetCurrentEventTimeSec(),
1903                  click_count_,
1904                  0,
1905                  &event);
1906    view_->handleInputEvent(event);
1907 }
1908
1909
1910 void EventSender::TrackpadScrollBegin() {
1911   WebMouseWheelEvent event;
1912   InitMouseEvent(WebInputEvent::MouseWheel,
1913                  WebMouseEvent::ButtonNone,
1914                  last_mouse_pos_,
1915                  GetCurrentEventTimeSec(),
1916                  click_count_,
1917                  0,
1918                  &event);
1919   event.phase = blink::WebMouseWheelEvent::PhaseBegan;
1920   event.hasPreciseScrollingDeltas = true;
1921   HandleInputEventOnViewOrPopup(event);
1922 }
1923
1924 void EventSender::TrackpadScroll(gin::Arguments* args) {
1925   WebMouseWheelEvent event;
1926   InitMouseWheelEvent(args, true, &event);
1927   event.phase = blink::WebMouseWheelEvent::PhaseChanged;
1928   event.hasPreciseScrollingDeltas = true;
1929   HandleInputEventOnViewOrPopup(event);
1930 }
1931
1932 void EventSender::TrackpadScrollEnd() {
1933   WebMouseWheelEvent event;
1934   InitMouseEvent(WebInputEvent::MouseWheel,
1935                  WebMouseEvent::ButtonNone,
1936                  last_mouse_pos_,
1937                  GetCurrentEventTimeSec(),
1938                  click_count_,
1939                  0,
1940                  &event);
1941   event.phase = WebMouseWheelEvent::PhaseEnded;
1942   event.hasPreciseScrollingDeltas = true;
1943   HandleInputEventOnViewOrPopup(event);
1944 }
1945
1946 void EventSender::MouseScrollBy(gin::Arguments* args) {
1947    WebMouseWheelEvent event;
1948   InitMouseWheelEvent(args, false, &event);
1949   HandleInputEventOnViewOrPopup(event);
1950 }
1951
1952 void EventSender::MouseMomentumBegin() {
1953   WebMouseWheelEvent event;
1954   InitMouseEvent(WebInputEvent::MouseWheel,
1955                  WebMouseEvent::ButtonNone,
1956                  last_mouse_pos_,
1957                  GetCurrentEventTimeSec(),
1958                  click_count_,
1959                  0,
1960                  &event);
1961   event.momentumPhase = WebMouseWheelEvent::PhaseBegan;
1962   event.hasPreciseScrollingDeltas = true;
1963   HandleInputEventOnViewOrPopup(event);
1964 }
1965
1966 void EventSender::MouseMomentumBegin2(gin::Arguments* args) {
1967   WebMouseWheelEvent event;
1968   InitMouseWheelEvent(args, true, &event);
1969   event.momentumPhase = WebMouseWheelEvent::PhaseBegan;
1970   event.hasPreciseScrollingDeltas = true;
1971   HandleInputEventOnViewOrPopup(event);
1972 }
1973
1974 void EventSender::MouseMomentumScrollBy(gin::Arguments* args) {
1975   WebMouseWheelEvent event;
1976   InitMouseWheelEvent(args, true, &event);
1977   event.momentumPhase = WebMouseWheelEvent::PhaseChanged;
1978   event.hasPreciseScrollingDeltas = true;
1979   HandleInputEventOnViewOrPopup(event);
1980 }
1981
1982 void EventSender::MouseMomentumEnd() {
1983   WebMouseWheelEvent event;
1984   InitMouseEvent(WebInputEvent::MouseWheel,
1985                  WebMouseEvent::ButtonNone,
1986                  last_mouse_pos_,
1987                  GetCurrentEventTimeSec(),
1988                  click_count_,
1989                  0,
1990                  &event);
1991   event.momentumPhase = WebMouseWheelEvent::PhaseEnded;
1992   event.hasPreciseScrollingDeltas = true;
1993   HandleInputEventOnViewOrPopup(event);
1994 }
1995
1996 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
1997   delegate_->PostTask(new MouseDownTask(this, button_number, modifiers));
1998   delegate_->PostTask(new MouseUpTask(this, button_number, modifiers));
1999 }
2000
2001 void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
2002                                               int modifiers,
2003                                               KeyLocationCode location) {
2004   delegate_->PostTask(new KeyDownTask(this, code_str, modifiers, location));
2005 }
2006
2007 double EventSender::GetCurrentEventTimeSec() {
2008   return (delegate_->GetCurrentTimeInMillisecond() + time_offset_ms_) / 1000.0;
2009 }
2010
2011 void EventSender::DoLeapForward(int milliseconds) {
2012   time_offset_ms_ += milliseconds;
2013 }
2014
2015 void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
2016                                         bool causesScrollingIfUncanceled) {
2017   DCHECK_GT(static_cast<unsigned>(WebTouchEvent::touchesLengthCap),
2018             touch_points_.size());
2019   if (force_layout_on_events_)
2020     view_->layout();
2021
2022   WebTouchEvent touch_event;
2023   touch_event.type = type;
2024   touch_event.modifiers = touch_modifiers_;
2025   touch_event.cancelable = touch_cancelable_;
2026   touch_event.timeStampSeconds = GetCurrentEventTimeSec();
2027   touch_event.causesScrollingIfUncanceled = causesScrollingIfUncanceled;
2028   touch_event.touchesLength = touch_points_.size();
2029   for (size_t i = 0; i < touch_points_.size(); ++i)
2030     touch_event.touches[i] = touch_points_[i];
2031   HandleInputEventOnViewOrPopup(touch_event);
2032
2033   for (size_t i = 0; i < touch_points_.size(); ++i) {
2034     WebTouchPoint* touch_point = &touch_points_[i];
2035     if (touch_point->state == WebTouchPoint::StateReleased) {
2036       touch_points_.erase(touch_points_.begin() + i);
2037       --i;
2038     } else
2039       touch_point->state = WebTouchPoint::StateStationary;
2040   }
2041 }
2042
2043 void EventSender::GestureEvent(WebInputEvent::Type type,
2044                                gin::Arguments* args) {
2045   WebGestureEvent event;
2046   event.type = type;
2047
2048   // If the first argument is a string, it is to specify the device, otherwise
2049   // the device is assumed to be a touchscreen (since most tests were written
2050   // assuming this).
2051   event.sourceDevice = blink::WebGestureDeviceTouchscreen;
2052   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) {
2053     std::string device_string;
2054     if (!args->GetNext(&device_string)) {
2055       args->ThrowError();
2056       return;
2057     }
2058     if (device_string == kSourceDeviceStringTouchpad) {
2059       event.sourceDevice = blink::WebGestureDeviceTouchpad;
2060     } else if (device_string == kSourceDeviceStringTouchscreen) {
2061       event.sourceDevice = blink::WebGestureDeviceTouchscreen;
2062     } else {
2063       args->ThrowError();
2064       return;
2065     }
2066   }
2067
2068   double x;
2069   double y;
2070   if (!args->GetNext(&x) || !args->GetNext(&y)) {
2071     args->ThrowError();
2072     return;
2073   }
2074
2075   switch (type) {
2076     case WebInputEvent::GestureScrollUpdate:
2077     {
2078       bool preventPropagation = false;
2079       if (!args->PeekNext().IsEmpty()) {
2080         if (!args->GetNext(&preventPropagation)) {
2081           args->ThrowError();
2082           return;
2083         }
2084       }
2085
2086       event.data.scrollUpdate.deltaX = static_cast<float>(x);
2087       event.data.scrollUpdate.deltaY = static_cast<float>(y);
2088       event.data.scrollUpdate.preventPropagation = preventPropagation;
2089       event.x = current_gesture_location_.x;
2090       event.y = current_gesture_location_.y;
2091       current_gesture_location_.x =
2092           current_gesture_location_.x + event.data.scrollUpdate.deltaX;
2093       current_gesture_location_.y =
2094           current_gesture_location_.y + event.data.scrollUpdate.deltaY;
2095       break;
2096     }
2097     case WebInputEvent::GestureScrollBegin:
2098       current_gesture_location_ = WebPoint(x, y);
2099       event.x = current_gesture_location_.x;
2100       event.y = current_gesture_location_.y;
2101       break;
2102     case WebInputEvent::GestureScrollEnd:
2103     case WebInputEvent::GestureFlingStart:
2104       event.x = current_gesture_location_.x;
2105       event.y = current_gesture_location_.y;
2106       break;
2107     case WebInputEvent::GesturePinchBegin:
2108     case WebInputEvent::GesturePinchEnd:
2109       current_gesture_location_ = WebPoint(x, y);
2110       event.x = current_gesture_location_.x;
2111       event.y = current_gesture_location_.y;
2112       break;
2113     case WebInputEvent::GesturePinchUpdate:
2114     {
2115       float scale = 1;
2116       if (!args->PeekNext().IsEmpty()) {
2117         if (!args->GetNext(&scale)) {
2118           args->ThrowError();
2119           return;
2120         }
2121       }
2122       event.data.pinchUpdate.scale = scale;
2123       current_gesture_location_ = WebPoint(x, y);
2124       event.x = current_gesture_location_.x;
2125       event.y = current_gesture_location_.y;
2126       break;
2127     }
2128     case WebInputEvent::GestureTap:
2129     {
2130       float tap_count = 1;
2131       float width = 30;
2132       float height = 30;
2133       if (!args->PeekNext().IsEmpty()) {
2134         if (!args->GetNext(&tap_count)) {
2135           args->ThrowError();
2136           return;
2137         }
2138       }
2139       if (!args->PeekNext().IsEmpty()) {
2140         if (!args->GetNext(&width)) {
2141           args->ThrowError();
2142           return;
2143         }
2144       }
2145       if (!args->PeekNext().IsEmpty()) {
2146         if (!args->GetNext(&height)) {
2147           args->ThrowError();
2148           return;
2149         }
2150       }
2151       event.data.tap.tapCount = tap_count;
2152       event.data.tap.width = width;
2153       event.data.tap.height = height;
2154       event.x = x;
2155       event.y = y;
2156       break;
2157     }
2158     case WebInputEvent::GestureTapUnconfirmed:
2159       if (!args->PeekNext().IsEmpty()) {
2160         float tap_count;
2161         if (!args->GetNext(&tap_count)) {
2162           args->ThrowError();
2163           return;
2164         }
2165         event.data.tap.tapCount = tap_count;
2166       } else {
2167         event.data.tap.tapCount = 1;
2168       }
2169       event.x = x;
2170       event.y = y;
2171       break;
2172     case WebInputEvent::GestureTapDown:
2173     {
2174       float width = 30;
2175       float height = 30;
2176       if (!args->PeekNext().IsEmpty()) {
2177         if (!args->GetNext(&width)) {
2178           args->ThrowError();
2179           return;
2180         }
2181       }
2182       if (!args->PeekNext().IsEmpty()) {
2183         if (!args->GetNext(&height)) {
2184           args->ThrowError();
2185           return;
2186         }
2187       }
2188       event.x = x;
2189       event.y = y;
2190       event.data.tapDown.width = width;
2191       event.data.tapDown.height = height;
2192       break;
2193     }
2194     case WebInputEvent::GestureShowPress:
2195     {
2196       float width = 30;
2197       float height = 30;
2198       if (!args->PeekNext().IsEmpty()) {
2199         if (!args->GetNext(&width)) {
2200           args->ThrowError();
2201           return;
2202         }
2203         if (!args->PeekNext().IsEmpty()) {
2204           if (!args->GetNext(&height)) {
2205             args->ThrowError();
2206             return;
2207           }
2208         }
2209       }
2210       event.x = x;
2211       event.y = y;
2212       event.data.showPress.width = width;
2213       event.data.showPress.height = height;
2214       break;
2215     }
2216     case WebInputEvent::GestureTapCancel:
2217       event.x = x;
2218       event.y = y;
2219       break;
2220     case WebInputEvent::GestureLongPress:
2221       event.x = x;
2222       event.y = y;
2223       if (!args->PeekNext().IsEmpty()) {
2224         float width;
2225         if (!args->GetNext(&width)) {
2226           args->ThrowError();
2227           return;
2228         }
2229         event.data.longPress.width = width;
2230         if (!args->PeekNext().IsEmpty()) {
2231           float height;
2232           if (!args->GetNext(&height)) {
2233             args->ThrowError();
2234             return;
2235           }
2236           event.data.longPress.height = height;
2237         }
2238       }
2239       break;
2240     case WebInputEvent::GestureLongTap:
2241       event.x = x;
2242       event.y = y;
2243       if (!args->PeekNext().IsEmpty()) {
2244         float width;
2245         if (!args->GetNext(&width)) {
2246           args->ThrowError();
2247           return;
2248         }
2249         event.data.longPress.width = width;
2250         if (!args->PeekNext().IsEmpty()) {
2251           float height;
2252           if (!args->GetNext(&height)) {
2253             args->ThrowError();
2254             return;
2255           }
2256           event.data.longPress.height = height;
2257         }
2258       }
2259       break;
2260     case WebInputEvent::GestureTwoFingerTap:
2261       event.x = x;
2262       event.y = y;
2263       if (!args->PeekNext().IsEmpty()) {
2264         float first_finger_width;
2265         if (!args->GetNext(&first_finger_width)) {
2266           args->ThrowError();
2267           return;
2268         }
2269         event.data.twoFingerTap.firstFingerWidth = first_finger_width;
2270         if (!args->PeekNext().IsEmpty()) {
2271           float first_finger_height;
2272           if (!args->GetNext(&first_finger_height)) {
2273             args->ThrowError();
2274             return;
2275           }
2276           event.data.twoFingerTap.firstFingerHeight = first_finger_height;
2277         }
2278       }
2279       break;
2280     default:
2281       NOTREACHED();
2282   }
2283
2284   event.globalX = event.x;
2285   event.globalY = event.y;
2286   event.timeStampSeconds = GetCurrentEventTimeSec();
2287
2288   if (force_layout_on_events_)
2289     view_->layout();
2290
2291   bool result = HandleInputEventOnViewOrPopup(event);
2292
2293   // Long press might start a drag drop session. Complete it if so.
2294   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
2295     WebMouseEvent mouse_event;
2296     InitMouseEvent(WebInputEvent::MouseDown,
2297                    pressed_button_,
2298                    WebPoint(x, y),
2299                    GetCurrentEventTimeSec(),
2300                    click_count_,
2301                    0,
2302                    &mouse_event);
2303
2304     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
2305   }
2306   args->Return(result);
2307 }
2308
2309 void EventSender::UpdateClickCountForButton(
2310     WebMouseEvent::Button button_type) {
2311   if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
2312        kMultipleClickTimeSec) &&
2313       (!OutsideMultiClickRadius(last_mouse_pos_, last_click_pos_)) &&
2314       (button_type == last_button_type_)) {
2315     ++click_count_;
2316   } else {
2317     click_count_ = 1;
2318     last_button_type_ = button_type;
2319   }
2320 }
2321
2322 void EventSender::InitMouseWheelEvent(gin::Arguments* args,
2323                                       bool continuous,
2324                                       WebMouseWheelEvent* event) {
2325   // Force a layout here just to make sure every position has been
2326   // determined before we send events (as well as all the other methods
2327   // that send an event do).
2328   if (force_layout_on_events_)
2329     view_->layout();
2330
2331   double horizontal;
2332   if (!args->GetNext(&horizontal)) {
2333     args->ThrowError();
2334     return;
2335   }
2336   double vertical;
2337   if (!args->GetNext(&vertical)) {
2338     args->ThrowError();
2339     return;
2340   }
2341
2342   bool paged = false;
2343   bool has_precise_scrolling_deltas = false;
2344   int modifiers = 0;
2345   bool can_scroll = true;
2346   if (!args->PeekNext().IsEmpty()) {
2347     args->GetNext(&paged);
2348     if (!args->PeekNext().IsEmpty()) {
2349       args->GetNext(&has_precise_scrolling_deltas);
2350       if (!args->PeekNext().IsEmpty()) {
2351         v8::Local<v8::Value> value;
2352         args->GetNext(&value);
2353         modifiers = GetKeyModifiersFromV8(args->isolate(), value);
2354         if (!args->PeekNext().IsEmpty())
2355           args->GetNext(&can_scroll);
2356       }
2357     }
2358   }
2359
2360   InitMouseEvent(WebInputEvent::MouseWheel,
2361                  pressed_button_,
2362                  last_mouse_pos_,
2363                  GetCurrentEventTimeSec(),
2364                  click_count_,
2365                  modifiers,
2366                  event);
2367   event->wheelTicksX = static_cast<float>(horizontal);
2368   event->wheelTicksY = static_cast<float>(vertical);
2369   event->deltaX = event->wheelTicksX;
2370   event->deltaY = event->wheelTicksY;
2371   event->scrollByPage = paged;
2372   event->hasPreciseScrollingDeltas = has_precise_scrolling_deltas;
2373   event->canScroll = can_scroll;
2374   if (continuous) {
2375     event->wheelTicksX /= kScrollbarPixelsPerTick;
2376     event->wheelTicksY /= kScrollbarPixelsPerTick;
2377   } else {
2378     event->deltaX *= kScrollbarPixelsPerTick;
2379     event->deltaY *= kScrollbarPixelsPerTick;
2380   }
2381 }
2382
2383 // Radius fields radius_x and radius_y should eventually be moved to
2384 // WebPointerProperties.
2385 // TODO(e_hakkinen): Drop radius_{x,y}_pointer parameters once that happens.
2386 void EventSender::InitPointerProperties(gin::Arguments* args,
2387                                         blink::WebPointerProperties* e,
2388                                         float* radius_x_pointer,
2389                                         float* radius_y_pointer) {
2390   if (!args->PeekNext().IsEmpty()) {
2391     double radius_x;
2392     if (!args->GetNext(&radius_x)) {
2393       args->ThrowError();
2394       return;
2395     }
2396
2397     double radius_y = radius_x;
2398     if (!args->PeekNext().IsEmpty()) {
2399       if (!args->GetNext(&radius_y)) {
2400         args->ThrowError();
2401         return;
2402       }
2403     }
2404
2405     *radius_x_pointer = static_cast<float>(radius_x);
2406     *radius_y_pointer = static_cast<float>(radius_y);
2407   }
2408
2409   if (!args->PeekNext().IsEmpty()) {
2410     double force;
2411     if (!args->GetNext(&force)) {
2412       args->ThrowError();
2413       return;
2414     }
2415     e->force = static_cast<float>(force);
2416   }
2417
2418   if (!args->PeekNext().IsEmpty()) {
2419     int tiltX, tiltY;
2420     if (!args->GetNext(&tiltX) || !args->GetNext(&tiltY)) {
2421       args->ThrowError();
2422       return;
2423     }
2424     e->tiltX = tiltX;
2425     e->tiltY = tiltY;
2426   }
2427
2428   if (!args->PeekNext().IsEmpty()) {
2429     std::string pointer_type_string;
2430     if (!args->GetNext(&pointer_type_string)) {
2431       args->ThrowError();
2432       return;
2433     }
2434     if (pointer_type_string == kPointerTypeStringUnknown) {
2435       e->pointerType = WebMouseEvent::PointerTypeUnknown;
2436     } else if (pointer_type_string == kPointerTypeStringMouse) {
2437       e->pointerType = WebMouseEvent::PointerTypeMouse;
2438     } else if (pointer_type_string == kPointerTypeStringPen) {
2439       e->pointerType = WebMouseEvent::PointerTypePen;
2440     } else if (pointer_type_string == kPointerTypeStringTouch) {
2441       e->pointerType = WebMouseEvent::PointerTypeTouch;
2442     } else {
2443       args->ThrowError();
2444       return;
2445     }
2446   }
2447 }
2448
2449 void EventSender::FinishDragAndDrop(const WebMouseEvent& e,
2450                                      blink::WebDragOperation drag_effect) {
2451   WebPoint client_point(e.x, e.y);
2452   WebPoint screen_point(e.globalX, e.globalY);
2453   current_drag_effect_ = drag_effect;
2454   if (current_drag_effect_) {
2455     // Specifically pass any keyboard modifiers to the drop method. This allows
2456     // tests to control the drop type (i.e. copy or move).
2457     view_->dragTargetDrop(client_point, screen_point, e.modifiers);
2458   } else {
2459     view_->dragTargetDragLeave();
2460   }
2461   view_->dragSourceEndedAt(client_point, screen_point, current_drag_effect_);
2462   view_->dragSourceSystemDragEnded();
2463
2464   current_drag_data_.reset();
2465 }
2466
2467 void EventSender::DoMouseUp(const WebMouseEvent& e) {
2468   HandleInputEventOnViewOrPopup(e);
2469
2470   pressed_button_ = WebMouseEvent::ButtonNone;
2471   last_click_time_sec_ = e.timeStampSeconds;
2472   last_click_pos_ = last_mouse_pos_;
2473
2474   // If we're in a drag operation, complete it.
2475   if (current_drag_data_.isNull())
2476     return;
2477
2478   WebPoint client_point(e.x, e.y);
2479   WebPoint screen_point(e.globalX, e.globalY);
2480   FinishDragAndDrop(
2481       e,
2482       view_->dragTargetDragOver(
2483           client_point,
2484           screen_point,
2485           current_drag_effects_allowed_,
2486           e.modifiers));
2487 }
2488
2489 void EventSender::DoMouseMove(const WebMouseEvent& e) {
2490   last_mouse_pos_ = WebPoint(e.x, e.y);
2491
2492   HandleInputEventOnViewOrPopup(e);
2493
2494   if (pressed_button_ == WebMouseEvent::ButtonNone ||
2495       current_drag_data_.isNull()) {
2496     return;
2497   }
2498
2499   WebPoint client_point(e.x, e.y);
2500   WebPoint screen_point(e.globalX, e.globalY);
2501   current_drag_effect_ = view_->dragTargetDragOver(
2502       client_point, screen_point, current_drag_effects_allowed_, e.modifiers);
2503 }
2504
2505 void EventSender::ReplaySavedEvents() {
2506   replaying_saved_events_ = true;
2507   while (!mouse_event_queue_.empty()) {
2508     SavedEvent e = mouse_event_queue_.front();
2509     mouse_event_queue_.pop_front();
2510
2511     switch (e.type) {
2512       case SavedEvent::TYPE_MOUSE_MOVE: {
2513         WebMouseEvent event;
2514         InitMouseEvent(WebInputEvent::MouseMove,
2515                        pressed_button_,
2516                        e.pos,
2517                        GetCurrentEventTimeSec(),
2518                        click_count_,
2519                        e.modifiers,
2520                        &event);
2521         DoMouseMove(event);
2522         break;
2523       }
2524       case SavedEvent::TYPE_LEAP_FORWARD:
2525         DoLeapForward(e.milliseconds);
2526         break;
2527       case SavedEvent::TYPE_MOUSE_UP: {
2528         WebMouseEvent event;
2529         InitMouseEvent(WebInputEvent::MouseUp,
2530                        e.button_type,
2531                        last_mouse_pos_,
2532                        GetCurrentEventTimeSec(),
2533                        click_count_,
2534                        e.modifiers,
2535                        &event);
2536         DoMouseUp(event);
2537         break;
2538       }
2539       default:
2540         NOTREACHED();
2541     }
2542   }
2543
2544   replaying_saved_events_ = false;
2545 }
2546
2547 bool EventSender::HandleInputEventOnViewOrPopup(const WebInputEvent& event) {
2548   if (WebPagePopup* popup = view_->pagePopup()) {
2549     if (!WebInputEvent::isKeyboardEventType(event.type))
2550       return popup->handleInputEvent(event);
2551   }
2552   return view_->handleInputEvent(event);
2553 }
2554
2555 }  // namespace test_runner