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_CONTROL;
1316     domString.assign("ControlLeft");
1317     location = DOMKeyLocationLeft;
1318   } else if ("rightControl" == code_str) {
1319     code = ui::VKEY_CONTROL;
1320     domString.assign("ControlRight");
1321     location = DOMKeyLocationRight;
1322   } else if ("leftShift" == code_str) {
1323     code = ui::VKEY_SHIFT;
1324     domString.assign("ShiftLeft");
1325     location = DOMKeyLocationLeft;
1326   } else if ("rightShift" == code_str) {
1327     code = ui::VKEY_SHIFT;
1328     domString.assign("ShiftRight");
1329     location = DOMKeyLocationRight;
1330   } else if ("leftAlt" == code_str) {
1331     code = ui::VKEY_MENU;
1332     domString.assign("AltLeft");
1333     location = DOMKeyLocationLeft;
1334   } else if ("rightAlt" == code_str) {
1335     code = ui::VKEY_MENU;
1336     domString.assign("AltRight");
1337     location = DOMKeyLocationRight;
1338   } else if ("numLock" == code_str) {
1339     code = ui::VKEY_NUMLOCK;
1340     domString.assign("NumLock");
1341   } else if ("backspace" == code_str) {
1342     code = ui::VKEY_BACK;
1343     domString.assign("Backspace");
1344   } else if ("escape" == code_str) {
1345     code = ui::VKEY_ESCAPE;
1346     domString.assign("Escape");
1347   } else {
1348     // Compare the input string with the function-key names defined by the
1349     // DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key
1350     // name, set its key code.
1351     for (int i = 1; i <= 24; ++i) {
1352       std::string function_key_name = base::StringPrintf("F%d", i);
1353       if (function_key_name == code_str) {
1354         code = ui::VKEY_F1 + (i - 1);
1355         domString = function_key_name;
1356         break;
1357       }
1358     }
1359     if (!code) {
1360       WebString web_code_str =
1361           WebString::fromUTF8(code_str.data(), code_str.size());
1362       if (web_code_str.length() != 1u) {
1363         v8::Isolate* isolate = blink::mainThreadIsolate();
1364         isolate->ThrowException(v8::Exception::TypeError(
1365             gin::StringToV8(isolate, "Invalid web code.")));
1366         return;
1367       }
1368       text = code = web_code_str.at(0);
1369       needs_shift_key_modifier = NeedsShiftModifier(code);
1370       if ((code & 0xFF) >= 'a' && (code & 0xFF) <= 'z')
1371         code -= 'a' - 'A';
1372       if ((code >= 'A' && code <= 'Z') || (code >= 'a' && code <= 'z')) {
1373         domString.assign("Key");
1374         domString.push_back(
1375             base::ToUpperASCII(static_cast<base::char16>(code)));
1376       } else if (code >= '0' && code <= '9') {
1377         domString.assign("Digit");
1378         domString.push_back(code);
1379       } else if (code == ' ') {
1380         domString.assign("Space");
1381       } else if (code == 9) {
1382         domString.assign("Tab");
1383       }
1384       generate_char = true;
1385     }
1386
1387     if ("(" == code_str) {
1388       code = '9';
1389       needs_shift_key_modifier = true;
1390     }
1391   }
1392
1393   // For one generated keyboard event, we need to generate a keyDown/keyUp
1394   // pair;
1395   // On Windows, we might also need to generate a char event to mimic the
1396   // Windows event flow; on other platforms we create a merged event and test
1397   // the event flow that that platform provides.
1398   WebKeyboardEvent event_down;
1399   event_down.type = WebInputEvent::RawKeyDown;
1400   event_down.modifiers = modifiers;
1401   event_down.windowsKeyCode = code;
1402   event_down.domCode = static_cast<int>(
1403       ui::KeycodeConverter::CodeStringToDomCode(domString.c_str()));
1404
1405   if (generate_char) {
1406     event_down.text[0] = text;
1407     event_down.unmodifiedText[0] = text;
1408   }
1409
1410   event_down.setKeyIdentifierFromWindowsKeyCode();
1411
1412   if (event_down.modifiers != 0)
1413     event_down.isSystemKey = IsSystemKeyEvent(event_down);
1414
1415   if (needs_shift_key_modifier)
1416     event_down.modifiers |= WebInputEvent::ShiftKey;
1417
1418   // See if KeyLocation argument is given.
1419   switch(location) {
1420   case DOMKeyLocationStandard:
1421     break;
1422   case DOMKeyLocationLeft:
1423     event_down.modifiers |= WebInputEvent::IsLeft;
1424     break;
1425   case DOMKeyLocationRight:
1426     event_down.modifiers |= WebInputEvent::IsRight;
1427     break;
1428   case DOMKeyLocationNumpad:
1429     event_down.modifiers |= WebInputEvent::IsKeyPad;
1430     break;
1431   }
1432
1433   WebKeyboardEvent event_up;
1434   event_up = event_down;
1435   event_up.type = WebInputEvent::KeyUp;
1436   // EventSender.m forces a layout here, with at least one
1437   // test (fast/forms/focus-control-to-page.html) relying on this.
1438   if (force_layout_on_events_)
1439     view_->layout();
1440
1441   // In the browser, if a keyboard event corresponds to an editor command,
1442   // the command will be dispatched to the renderer just before dispatching
1443   // the keyboard event, and then it will be executed in the
1444   // RenderView::handleCurrentKeyboardEvent() method.
1445   // We just simulate the same behavior here.
1446   std::string edit_command;
1447   if (GetEditCommand(event_down, &edit_command))
1448     delegate_->SetEditCommand(edit_command, "");
1449
1450   HandleInputEventOnViewOrPopup(event_down);
1451
1452   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
1453     WebMouseEvent event;
1454     InitMouseEvent(WebInputEvent::MouseDown,
1455                    pressed_button_,
1456                    last_mouse_pos_,
1457                    GetCurrentEventTimeSec(),
1458                    click_count_,
1459                    0,
1460                    &event);
1461     FinishDragAndDrop(event, blink::WebDragOperationNone);
1462   }
1463
1464   delegate_->ClearEditCommand();
1465
1466   if (generate_char) {
1467     WebKeyboardEvent event_char = event_up;
1468     event_char.type = WebInputEvent::Char;
1469     // keyIdentifier is an empty string, unless the Enter key was pressed.
1470     // This behavior is not standard (keyIdentifier itself is not even a
1471     // standard any more), but it matches the actual behavior in Blink.
1472     if (code != ui::VKEY_RETURN)
1473       event_char.keyIdentifier[0] = '\0';
1474     HandleInputEventOnViewOrPopup(event_char);
1475   }
1476
1477   HandleInputEventOnViewOrPopup(event_up);
1478 }
1479
1480 void EventSender::EnableDOMUIEventLogging() {}
1481
1482 void EventSender::FireKeyboardEventsToElement() {}
1483
1484 void EventSender::ClearKillRing() {}
1485
1486 std::vector<std::string> EventSender::ContextClick() {
1487   if (force_layout_on_events_) {
1488     view_->layout();
1489   }
1490
1491   UpdateClickCountForButton(WebMouseEvent::ButtonRight);
1492
1493   // Clears last context menu data because we need to know if the context menu
1494   // be requested after following mouse events.
1495   last_context_menu_data_.reset();
1496
1497   // Generate right mouse down and up.
1498   WebMouseEvent event;
1499   // This is a hack to work around only allowing a single pressed button since
1500   // we want to test the case where both the left and right mouse buttons are
1501   // pressed.
1502   if (pressed_button_ == WebMouseEvent::ButtonNone) {
1503     pressed_button_ = WebMouseEvent::ButtonRight;
1504   }
1505   InitMouseEvent(WebInputEvent::MouseDown,
1506                  WebMouseEvent::ButtonRight,
1507                  last_mouse_pos_,
1508                  GetCurrentEventTimeSec(),
1509                  click_count_,
1510                  0,
1511                  &event);
1512   HandleInputEventOnViewOrPopup(event);
1513
1514 #if defined(OS_WIN)
1515   InitMouseEvent(WebInputEvent::MouseUp,
1516                  WebMouseEvent::ButtonRight,
1517                  last_mouse_pos_,
1518                  GetCurrentEventTimeSec(),
1519                  click_count_,
1520                  0,
1521                  &event);
1522   HandleInputEventOnViewOrPopup(event);
1523
1524   pressed_button_= WebMouseEvent::ButtonNone;
1525 #endif
1526
1527   std::vector<std::string> menu_items =
1528       MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate_);
1529   last_context_menu_data_.reset();
1530   return menu_items;
1531 }
1532
1533 void EventSender::TextZoomIn() {
1534   view_->setTextZoomFactor(view_->textZoomFactor() * 1.2f);
1535 }
1536
1537 void EventSender::TextZoomOut() {
1538   view_->setTextZoomFactor(view_->textZoomFactor() / 1.2f);
1539 }
1540
1541 void EventSender::ZoomPageIn() {
1542   const std::vector<WebTestProxyBase*>& window_list =
1543       interfaces_->GetWindowList();
1544
1545   for (size_t i = 0; i < window_list.size(); ++i) {
1546     window_list.at(i)->GetWebView()->setZoomLevel(
1547         window_list.at(i)->GetWebView()->zoomLevel() + 1);
1548   }
1549 }
1550
1551 void EventSender::ZoomPageOut() {
1552   const std::vector<WebTestProxyBase*>& window_list =
1553       interfaces_->GetWindowList();
1554
1555   for (size_t i = 0; i < window_list.size(); ++i) {
1556     window_list.at(i)->GetWebView()->setZoomLevel(
1557         window_list.at(i)->GetWebView()->zoomLevel() - 1);
1558   }
1559 }
1560
1561 void EventSender::SetPageZoomFactor(double zoom_factor) {
1562   const std::vector<WebTestProxyBase*>& window_list =
1563       interfaces_->GetWindowList();
1564
1565   for (size_t i = 0; i < window_list.size(); ++i) {
1566     window_list.at(i)->GetWebView()->setZoomLevel(
1567         std::log(zoom_factor) / std::log(1.2));
1568   }
1569 }
1570
1571 void EventSender::ClearTouchPoints() {
1572   touch_points_.clear();
1573 }
1574
1575 void EventSender::ThrowTouchPointError() {
1576   v8::Isolate* isolate = blink::mainThreadIsolate();
1577   isolate->ThrowException(v8::Exception::TypeError(
1578       gin::StringToV8(isolate, "Invalid touch point.")));
1579 }
1580
1581 void EventSender::ReleaseTouchPoint(unsigned index) {
1582   if (index >= touch_points_.size()) {
1583     ThrowTouchPointError();
1584     return;
1585   }
1586
1587   WebTouchPoint* touch_point = &touch_points_[index];
1588   touch_point->state = WebTouchPoint::StateReleased;
1589 }
1590
1591 void EventSender::UpdateTouchPoint(unsigned index,
1592                                    float x,
1593                                    float y,
1594                                    gin::Arguments* args) {
1595   if (index >= touch_points_.size()) {
1596     ThrowTouchPointError();
1597     return;
1598   }
1599
1600   WebTouchPoint* touch_point = &touch_points_[index];
1601   touch_point->state = WebTouchPoint::StateMoved;
1602   touch_point->position = WebFloatPoint(x, y);
1603   touch_point->screenPosition = touch_point->position;
1604
1605   InitPointerProperties(args, touch_point, &touch_point->radiusX,
1606                         &touch_point->radiusY);
1607 }
1608
1609 void EventSender::CancelTouchPoint(unsigned index) {
1610   if (index >= touch_points_.size()) {
1611     ThrowTouchPointError();
1612     return;
1613   }
1614
1615   WebTouchPoint* touch_point = &touch_points_[index];
1616   touch_point->state = WebTouchPoint::StateCancelled;
1617 }
1618
1619 void EventSender::SetTouchModifier(const std::string& key_name,
1620                                     bool set_mask) {
1621   int mask = 0;
1622   if (key_name == "shift")
1623     mask = WebInputEvent::ShiftKey;
1624   else if (key_name == "alt")
1625     mask = WebInputEvent::AltKey;
1626   else if (key_name == "ctrl")
1627     mask = WebInputEvent::ControlKey;
1628   else if (key_name == "meta")
1629     mask = WebInputEvent::MetaKey;
1630
1631   if (set_mask)
1632     touch_modifiers_ |= mask;
1633   else
1634     touch_modifiers_ &= ~mask;
1635 }
1636
1637 void EventSender::SetTouchCancelable(bool cancelable) {
1638   touch_cancelable_ = cancelable;
1639 }
1640
1641 void EventSender::DumpFilenameBeingDragged() {
1642   if (current_drag_data_.isNull())
1643     return;
1644
1645   WebString filename;
1646   WebVector<WebDragData::Item> items = current_drag_data_.items();
1647   for (size_t i = 0; i < items.size(); ++i) {
1648     if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
1649       filename = items[i].title;
1650       break;
1651     }
1652   }
1653   delegate_->PrintMessage(std::string("Filename being dragged: ") +
1654                           filename.utf8().data() + "\n");
1655 }
1656
1657 void EventSender::GestureFlingCancel() {
1658   WebGestureEvent event;
1659   event.type = WebInputEvent::GestureFlingCancel;
1660   event.timeStampSeconds = GetCurrentEventTimeSec();
1661
1662   if (force_layout_on_events_)
1663     view_->layout();
1664
1665   HandleInputEventOnViewOrPopup(event);
1666 }
1667
1668 void EventSender::GestureFlingStart(float x,
1669                                     float y,
1670                                     float velocity_x,
1671                                     float velocity_y,
1672                                     gin::Arguments* args) {
1673   WebGestureEvent event;
1674   event.type = WebInputEvent::GestureFlingStart;
1675
1676   std::string device_string;
1677   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString())
1678     args->GetNext(&device_string);
1679
1680   if (device_string == kSourceDeviceStringTouchpad) {
1681     event.sourceDevice = blink::WebGestureDeviceTouchpad;
1682   } else if (device_string == kSourceDeviceStringTouchscreen) {
1683     event.sourceDevice = blink::WebGestureDeviceTouchscreen;
1684   } else {
1685     args->ThrowError();
1686     return;
1687   }
1688
1689   event.x = x;
1690   event.y = y;
1691   event.globalX = event.x;
1692   event.globalY = event.y;
1693
1694   event.data.flingStart.velocityX = velocity_x;
1695   event.data.flingStart.velocityY = velocity_y;
1696   event.timeStampSeconds = GetCurrentEventTimeSec();
1697
1698   if (force_layout_on_events_)
1699     view_->layout();
1700
1701   HandleInputEventOnViewOrPopup(event);
1702 }
1703
1704 void EventSender::GestureScrollFirstPoint(int x, int y) {
1705   current_gesture_location_ = WebPoint(x, y);
1706 }
1707
1708 void EventSender::TouchStart() {
1709   SendCurrentTouchEvent(WebInputEvent::TouchStart, false);
1710 }
1711
1712 void EventSender::TouchMove() {
1713   SendCurrentTouchEvent(WebInputEvent::TouchMove, false);
1714 }
1715
1716 void EventSender::TouchMoveCausingScrollIfUncanceled() {
1717   SendCurrentTouchEvent(WebInputEvent::TouchMove, true);
1718 }
1719
1720 void EventSender::TouchCancel() {
1721   SendCurrentTouchEvent(WebInputEvent::TouchCancel, false);
1722 }
1723
1724 void EventSender::TouchEnd() {
1725   SendCurrentTouchEvent(WebInputEvent::TouchEnd, false);
1726 }
1727
1728 void EventSender::LeapForward(int milliseconds) {
1729   if (is_drag_mode_ && pressed_button_ == WebMouseEvent::ButtonLeft &&
1730       !replaying_saved_events_) {
1731     SavedEvent saved_event;
1732     saved_event.type = SavedEvent::TYPE_LEAP_FORWARD;
1733     saved_event.milliseconds = milliseconds;
1734     mouse_event_queue_.push_back(saved_event);
1735   } else {
1736     DoLeapForward(milliseconds);
1737   }
1738 }
1739
1740 void EventSender::BeginDragWithFiles(const std::vector<std::string>& files) {
1741   current_drag_data_.initialize();
1742   WebVector<WebString> absolute_filenames(files.size());
1743   for (size_t i = 0; i < files.size(); ++i) {
1744     WebDragData::Item item;
1745     item.storageType = WebDragData::Item::StorageTypeFilename;
1746     item.filenameData = delegate_->GetAbsoluteWebStringFromUTF8Path(files[i]);
1747     current_drag_data_.addItem(item);
1748     absolute_filenames[i] = item.filenameData;
1749   }
1750   current_drag_data_.setFilesystemId(
1751       delegate_->RegisterIsolatedFileSystem(absolute_filenames));
1752   current_drag_effects_allowed_ = blink::WebDragOperationCopy;
1753
1754   // Provide a drag source.
1755   view_->dragTargetDragEnter(current_drag_data_,
1756                              last_mouse_pos_,
1757                              last_mouse_pos_,
1758                              current_drag_effects_allowed_,
1759                              0);
1760   // |is_drag_mode_| saves events and then replays them later. We don't
1761   // need/want that.
1762   is_drag_mode_ = false;
1763
1764   // Make the rest of eventSender think a drag is in progress.
1765   pressed_button_ = WebMouseEvent::ButtonLeft;
1766 }
1767
1768 void EventSender::AddTouchPoint(float x, float y, gin::Arguments* args) {
1769   WebTouchPoint touch_point;
1770   touch_point.state = WebTouchPoint::StatePressed;
1771   touch_point.position = WebFloatPoint(x, y);
1772   touch_point.screenPosition = touch_point.position;
1773
1774   int highest_id = -1;
1775   for (size_t i = 0; i < touch_points_.size(); i++) {
1776     if (touch_points_[i].id > highest_id)
1777       highest_id = touch_points_[i].id;
1778   }
1779   touch_point.id = highest_id + 1;
1780
1781   InitPointerProperties(args, &touch_point, &touch_point.radiusX,
1782                         &touch_point.radiusY);
1783
1784   touch_points_.push_back(touch_point);
1785 }
1786
1787 void EventSender::MouseDragBegin() {
1788   WebMouseWheelEvent event;
1789   InitMouseEvent(WebInputEvent::MouseWheel,
1790                  WebMouseEvent::ButtonNone,
1791                  last_mouse_pos_,
1792                  GetCurrentEventTimeSec(),
1793                  click_count_,
1794                  0,
1795                  &event);
1796   event.phase = WebMouseWheelEvent::PhaseBegan;
1797   event.hasPreciseScrollingDeltas = true;
1798   HandleInputEventOnViewOrPopup(event);
1799 }
1800
1801 void EventSender::MouseDragEnd() {
1802   WebMouseWheelEvent event;
1803   InitMouseEvent(WebInputEvent::MouseWheel,
1804                  WebMouseEvent::ButtonNone,
1805                  last_mouse_pos_,
1806                  GetCurrentEventTimeSec(),
1807                  click_count_,
1808                  0,
1809                  &event);
1810   event.phase = WebMouseWheelEvent::PhaseEnded;
1811   event.hasPreciseScrollingDeltas = true;
1812   HandleInputEventOnViewOrPopup(event);
1813 }
1814
1815 void EventSender::GestureScrollBegin(gin::Arguments* args) {
1816   GestureEvent(WebInputEvent::GestureScrollBegin, args);
1817 }
1818
1819 void EventSender::GestureScrollEnd(gin::Arguments* args) {
1820   GestureEvent(WebInputEvent::GestureScrollEnd, args);
1821 }
1822
1823 void EventSender::GestureScrollUpdate(gin::Arguments* args) {
1824   GestureEvent(WebInputEvent::GestureScrollUpdate, args);
1825 }
1826
1827 void EventSender::GesturePinchBegin(gin::Arguments* args) {
1828   GestureEvent(WebInputEvent::GesturePinchBegin, args);
1829 }
1830
1831 void EventSender::GesturePinchEnd(gin::Arguments* args) {
1832   GestureEvent(WebInputEvent::GesturePinchEnd, args);
1833 }
1834
1835 void EventSender::GesturePinchUpdate(gin::Arguments* args) {
1836   GestureEvent(WebInputEvent::GesturePinchUpdate, args);
1837 }
1838
1839 void EventSender::GestureTap(gin::Arguments* args) {
1840   GestureEvent(WebInputEvent::GestureTap, args);
1841 }
1842
1843 void EventSender::GestureTapDown(gin::Arguments* args) {
1844   GestureEvent(WebInputEvent::GestureTapDown, args);
1845 }
1846
1847 void EventSender::GestureShowPress(gin::Arguments* args) {
1848   GestureEvent(WebInputEvent::GestureShowPress, args);
1849 }
1850
1851 void EventSender::GestureTapCancel(gin::Arguments* args) {
1852   GestureEvent(WebInputEvent::GestureTapCancel, args);
1853 }
1854
1855 void EventSender::GestureLongPress(gin::Arguments* args) {
1856   GestureEvent(WebInputEvent::GestureLongPress, args);
1857 }
1858
1859 void EventSender::GestureLongTap(gin::Arguments* args) {
1860   GestureEvent(WebInputEvent::GestureLongTap, args);
1861 }
1862
1863 void EventSender::GestureTwoFingerTap(gin::Arguments* args) {
1864   GestureEvent(WebInputEvent::GestureTwoFingerTap, args);
1865 }
1866
1867 void EventSender::ContinuousMouseScrollBy(gin::Arguments* args) {
1868   WebMouseWheelEvent event;
1869   InitMouseWheelEvent(args, true, &event);
1870   HandleInputEventOnViewOrPopup(event);
1871 }
1872
1873 void EventSender::MouseMoveTo(gin::Arguments* args) {
1874   if (force_layout_on_events_)
1875     view_->layout();
1876
1877   double x;
1878   double y;
1879   if (!args->GetNext(&x) || !args->GetNext(&y)) {
1880     args->ThrowError();
1881     return;
1882   }
1883   WebPoint mouse_pos(static_cast<int>(x), static_cast<int>(y));
1884
1885   int modifiers = 0;
1886   if (!args->PeekNext().IsEmpty())
1887     modifiers = GetKeyModifiersFromV8(args->isolate(), args->PeekNext());
1888
1889   if (is_drag_mode_ && pressed_button_ == WebMouseEvent::ButtonLeft &&
1890       !replaying_saved_events_) {
1891     SavedEvent saved_event;
1892     saved_event.type = SavedEvent::TYPE_MOUSE_MOVE;
1893     saved_event.pos = mouse_pos;
1894     saved_event.modifiers = modifiers;
1895     mouse_event_queue_.push_back(saved_event);
1896   } else {
1897     WebMouseEvent event;
1898     InitMouseEvent(WebInputEvent::MouseMove,
1899                    pressed_button_,
1900                    mouse_pos,
1901                    GetCurrentEventTimeSec(),
1902                    click_count_,
1903                    modifiers,
1904                    &event);
1905     DoMouseMove(event);
1906   }
1907 }
1908
1909 void EventSender::MouseLeave() {
1910   if (force_layout_on_events_)
1911     view_->layout();
1912
1913   WebMouseEvent event;
1914   InitMouseEvent(WebInputEvent::MouseLeave,
1915                  WebMouseEvent::ButtonNone,
1916                  last_mouse_pos_,
1917                  GetCurrentEventTimeSec(),
1918                  click_count_,
1919                  0,
1920                  &event);
1921    view_->handleInputEvent(event);
1922 }
1923
1924
1925 void EventSender::TrackpadScrollBegin() {
1926   WebMouseWheelEvent event;
1927   InitMouseEvent(WebInputEvent::MouseWheel,
1928                  WebMouseEvent::ButtonNone,
1929                  last_mouse_pos_,
1930                  GetCurrentEventTimeSec(),
1931                  click_count_,
1932                  0,
1933                  &event);
1934   event.phase = blink::WebMouseWheelEvent::PhaseBegan;
1935   event.hasPreciseScrollingDeltas = true;
1936   HandleInputEventOnViewOrPopup(event);
1937 }
1938
1939 void EventSender::TrackpadScroll(gin::Arguments* args) {
1940   WebMouseWheelEvent event;
1941   InitMouseWheelEvent(args, true, &event);
1942   event.phase = blink::WebMouseWheelEvent::PhaseChanged;
1943   event.hasPreciseScrollingDeltas = true;
1944   HandleInputEventOnViewOrPopup(event);
1945 }
1946
1947 void EventSender::TrackpadScrollEnd() {
1948   WebMouseWheelEvent event;
1949   InitMouseEvent(WebInputEvent::MouseWheel,
1950                  WebMouseEvent::ButtonNone,
1951                  last_mouse_pos_,
1952                  GetCurrentEventTimeSec(),
1953                  click_count_,
1954                  0,
1955                  &event);
1956   event.phase = WebMouseWheelEvent::PhaseEnded;
1957   event.hasPreciseScrollingDeltas = true;
1958   HandleInputEventOnViewOrPopup(event);
1959 }
1960
1961 void EventSender::MouseScrollBy(gin::Arguments* args) {
1962    WebMouseWheelEvent event;
1963   InitMouseWheelEvent(args, false, &event);
1964   HandleInputEventOnViewOrPopup(event);
1965 }
1966
1967 void EventSender::MouseMomentumBegin() {
1968   WebMouseWheelEvent event;
1969   InitMouseEvent(WebInputEvent::MouseWheel,
1970                  WebMouseEvent::ButtonNone,
1971                  last_mouse_pos_,
1972                  GetCurrentEventTimeSec(),
1973                  click_count_,
1974                  0,
1975                  &event);
1976   event.momentumPhase = WebMouseWheelEvent::PhaseBegan;
1977   event.hasPreciseScrollingDeltas = true;
1978   HandleInputEventOnViewOrPopup(event);
1979 }
1980
1981 void EventSender::MouseMomentumBegin2(gin::Arguments* args) {
1982   WebMouseWheelEvent event;
1983   InitMouseWheelEvent(args, true, &event);
1984   event.momentumPhase = WebMouseWheelEvent::PhaseBegan;
1985   event.hasPreciseScrollingDeltas = true;
1986   HandleInputEventOnViewOrPopup(event);
1987 }
1988
1989 void EventSender::MouseMomentumScrollBy(gin::Arguments* args) {
1990   WebMouseWheelEvent event;
1991   InitMouseWheelEvent(args, true, &event);
1992   event.momentumPhase = WebMouseWheelEvent::PhaseChanged;
1993   event.hasPreciseScrollingDeltas = true;
1994   HandleInputEventOnViewOrPopup(event);
1995 }
1996
1997 void EventSender::MouseMomentumEnd() {
1998   WebMouseWheelEvent event;
1999   InitMouseEvent(WebInputEvent::MouseWheel,
2000                  WebMouseEvent::ButtonNone,
2001                  last_mouse_pos_,
2002                  GetCurrentEventTimeSec(),
2003                  click_count_,
2004                  0,
2005                  &event);
2006   event.momentumPhase = WebMouseWheelEvent::PhaseEnded;
2007   event.hasPreciseScrollingDeltas = true;
2008   HandleInputEventOnViewOrPopup(event);
2009 }
2010
2011 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
2012   delegate_->PostTask(new MouseDownTask(this, button_number, modifiers));
2013   delegate_->PostTask(new MouseUpTask(this, button_number, modifiers));
2014 }
2015
2016 void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
2017                                               int modifiers,
2018                                               KeyLocationCode location) {
2019   delegate_->PostTask(new KeyDownTask(this, code_str, modifiers, location));
2020 }
2021
2022 double EventSender::GetCurrentEventTimeSec() {
2023   return (delegate_->GetCurrentTimeInMillisecond() + time_offset_ms_) / 1000.0;
2024 }
2025
2026 void EventSender::DoLeapForward(int milliseconds) {
2027   time_offset_ms_ += milliseconds;
2028 }
2029
2030 void EventSender::SendCurrentTouchEvent(WebInputEvent::Type type,
2031                                         bool causesScrollingIfUncanceled) {
2032   DCHECK_GT(static_cast<unsigned>(WebTouchEvent::touchesLengthCap),
2033             touch_points_.size());
2034   if (force_layout_on_events_)
2035     view_->layout();
2036
2037   WebTouchEvent touch_event;
2038   touch_event.type = type;
2039   touch_event.modifiers = touch_modifiers_;
2040   touch_event.cancelable = touch_cancelable_;
2041   touch_event.timeStampSeconds = GetCurrentEventTimeSec();
2042   touch_event.causesScrollingIfUncanceled = causesScrollingIfUncanceled;
2043   touch_event.touchesLength = touch_points_.size();
2044   for (size_t i = 0; i < touch_points_.size(); ++i)
2045     touch_event.touches[i] = touch_points_[i];
2046   HandleInputEventOnViewOrPopup(touch_event);
2047
2048   for (size_t i = 0; i < touch_points_.size(); ++i) {
2049     WebTouchPoint* touch_point = &touch_points_[i];
2050     if (touch_point->state == WebTouchPoint::StateReleased
2051         || touch_point->state == WebTouchPoint::StateCancelled) {
2052       touch_points_.erase(touch_points_.begin() + i);
2053       --i;
2054     } else
2055       touch_point->state = WebTouchPoint::StateStationary;
2056   }
2057 }
2058
2059 void EventSender::GestureEvent(WebInputEvent::Type type,
2060                                gin::Arguments* args) {
2061   WebGestureEvent event;
2062   event.type = type;
2063
2064   // If the first argument is a string, it is to specify the device, otherwise
2065   // the device is assumed to be a touchscreen (since most tests were written
2066   // assuming this).
2067   event.sourceDevice = blink::WebGestureDeviceTouchscreen;
2068   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) {
2069     std::string device_string;
2070     if (!args->GetNext(&device_string)) {
2071       args->ThrowError();
2072       return;
2073     }
2074     if (device_string == kSourceDeviceStringTouchpad) {
2075       event.sourceDevice = blink::WebGestureDeviceTouchpad;
2076     } else if (device_string == kSourceDeviceStringTouchscreen) {
2077       event.sourceDevice = blink::WebGestureDeviceTouchscreen;
2078     } else {
2079       args->ThrowError();
2080       return;
2081     }
2082   }
2083
2084   double x;
2085   double y;
2086   if (!args->GetNext(&x) || !args->GetNext(&y)) {
2087     args->ThrowError();
2088     return;
2089   }
2090
2091   switch (type) {
2092     case WebInputEvent::GestureScrollUpdate:
2093     {
2094       bool preventPropagation = false;
2095       if (!args->PeekNext().IsEmpty()) {
2096         if (!args->GetNext(&preventPropagation)) {
2097           args->ThrowError();
2098           return;
2099         }
2100       }
2101
2102       event.data.scrollUpdate.deltaX = static_cast<float>(x);
2103       event.data.scrollUpdate.deltaY = static_cast<float>(y);
2104       event.data.scrollUpdate.preventPropagation = preventPropagation;
2105       event.x = current_gesture_location_.x;
2106       event.y = current_gesture_location_.y;
2107       current_gesture_location_.x =
2108           current_gesture_location_.x + event.data.scrollUpdate.deltaX;
2109       current_gesture_location_.y =
2110           current_gesture_location_.y + event.data.scrollUpdate.deltaY;
2111       break;
2112     }
2113     case WebInputEvent::GestureScrollBegin:
2114       current_gesture_location_ = WebPoint(x, y);
2115       event.x = current_gesture_location_.x;
2116       event.y = current_gesture_location_.y;
2117       break;
2118     case WebInputEvent::GestureScrollEnd:
2119     case WebInputEvent::GestureFlingStart:
2120       event.x = current_gesture_location_.x;
2121       event.y = current_gesture_location_.y;
2122       break;
2123     case WebInputEvent::GesturePinchBegin:
2124     case WebInputEvent::GesturePinchEnd:
2125       current_gesture_location_ = WebPoint(x, y);
2126       event.x = current_gesture_location_.x;
2127       event.y = current_gesture_location_.y;
2128       break;
2129     case WebInputEvent::GesturePinchUpdate:
2130     {
2131       float scale = 1;
2132       if (!args->PeekNext().IsEmpty()) {
2133         if (!args->GetNext(&scale)) {
2134           args->ThrowError();
2135           return;
2136         }
2137       }
2138       event.data.pinchUpdate.scale = scale;
2139       current_gesture_location_ = WebPoint(x, y);
2140       event.x = current_gesture_location_.x;
2141       event.y = current_gesture_location_.y;
2142       break;
2143     }
2144     case WebInputEvent::GestureTap:
2145     {
2146       float tap_count = 1;
2147       float width = 30;
2148       float height = 30;
2149       if (!args->PeekNext().IsEmpty()) {
2150         if (!args->GetNext(&tap_count)) {
2151           args->ThrowError();
2152           return;
2153         }
2154       }
2155       if (!args->PeekNext().IsEmpty()) {
2156         if (!args->GetNext(&width)) {
2157           args->ThrowError();
2158           return;
2159         }
2160       }
2161       if (!args->PeekNext().IsEmpty()) {
2162         if (!args->GetNext(&height)) {
2163           args->ThrowError();
2164           return;
2165         }
2166       }
2167       event.data.tap.tapCount = tap_count;
2168       event.data.tap.width = width;
2169       event.data.tap.height = height;
2170       event.x = x;
2171       event.y = y;
2172       break;
2173     }
2174     case WebInputEvent::GestureTapUnconfirmed:
2175       if (!args->PeekNext().IsEmpty()) {
2176         float tap_count;
2177         if (!args->GetNext(&tap_count)) {
2178           args->ThrowError();
2179           return;
2180         }
2181         event.data.tap.tapCount = tap_count;
2182       } else {
2183         event.data.tap.tapCount = 1;
2184       }
2185       event.x = x;
2186       event.y = y;
2187       break;
2188     case WebInputEvent::GestureTapDown:
2189     {
2190       float width = 30;
2191       float height = 30;
2192       if (!args->PeekNext().IsEmpty()) {
2193         if (!args->GetNext(&width)) {
2194           args->ThrowError();
2195           return;
2196         }
2197       }
2198       if (!args->PeekNext().IsEmpty()) {
2199         if (!args->GetNext(&height)) {
2200           args->ThrowError();
2201           return;
2202         }
2203       }
2204       event.x = x;
2205       event.y = y;
2206       event.data.tapDown.width = width;
2207       event.data.tapDown.height = height;
2208       break;
2209     }
2210     case WebInputEvent::GestureShowPress:
2211     {
2212       float width = 30;
2213       float height = 30;
2214       if (!args->PeekNext().IsEmpty()) {
2215         if (!args->GetNext(&width)) {
2216           args->ThrowError();
2217           return;
2218         }
2219         if (!args->PeekNext().IsEmpty()) {
2220           if (!args->GetNext(&height)) {
2221             args->ThrowError();
2222             return;
2223           }
2224         }
2225       }
2226       event.x = x;
2227       event.y = y;
2228       event.data.showPress.width = width;
2229       event.data.showPress.height = height;
2230       break;
2231     }
2232     case WebInputEvent::GestureTapCancel:
2233       event.x = x;
2234       event.y = y;
2235       break;
2236     case WebInputEvent::GestureLongPress:
2237       event.x = x;
2238       event.y = y;
2239       if (!args->PeekNext().IsEmpty()) {
2240         float width;
2241         if (!args->GetNext(&width)) {
2242           args->ThrowError();
2243           return;
2244         }
2245         event.data.longPress.width = width;
2246         if (!args->PeekNext().IsEmpty()) {
2247           float height;
2248           if (!args->GetNext(&height)) {
2249             args->ThrowError();
2250             return;
2251           }
2252           event.data.longPress.height = height;
2253         }
2254       }
2255       break;
2256     case WebInputEvent::GestureLongTap:
2257       event.x = x;
2258       event.y = y;
2259       if (!args->PeekNext().IsEmpty()) {
2260         float width;
2261         if (!args->GetNext(&width)) {
2262           args->ThrowError();
2263           return;
2264         }
2265         event.data.longPress.width = width;
2266         if (!args->PeekNext().IsEmpty()) {
2267           float height;
2268           if (!args->GetNext(&height)) {
2269             args->ThrowError();
2270             return;
2271           }
2272           event.data.longPress.height = height;
2273         }
2274       }
2275       break;
2276     case WebInputEvent::GestureTwoFingerTap:
2277       event.x = x;
2278       event.y = y;
2279       if (!args->PeekNext().IsEmpty()) {
2280         float first_finger_width;
2281         if (!args->GetNext(&first_finger_width)) {
2282           args->ThrowError();
2283           return;
2284         }
2285         event.data.twoFingerTap.firstFingerWidth = first_finger_width;
2286         if (!args->PeekNext().IsEmpty()) {
2287           float first_finger_height;
2288           if (!args->GetNext(&first_finger_height)) {
2289             args->ThrowError();
2290             return;
2291           }
2292           event.data.twoFingerTap.firstFingerHeight = first_finger_height;
2293         }
2294       }
2295       break;
2296     default:
2297       NOTREACHED();
2298   }
2299
2300   event.globalX = event.x;
2301   event.globalY = event.y;
2302   event.timeStampSeconds = GetCurrentEventTimeSec();
2303
2304   if (force_layout_on_events_)
2305     view_->layout();
2306
2307   bool result = HandleInputEventOnViewOrPopup(event);
2308
2309   // Long press might start a drag drop session. Complete it if so.
2310   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
2311     WebMouseEvent mouse_event;
2312     InitMouseEvent(WebInputEvent::MouseDown,
2313                    pressed_button_,
2314                    WebPoint(x, y),
2315                    GetCurrentEventTimeSec(),
2316                    click_count_,
2317                    0,
2318                    &mouse_event);
2319
2320     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
2321   }
2322   args->Return(result);
2323 }
2324
2325 void EventSender::UpdateClickCountForButton(
2326     WebMouseEvent::Button button_type) {
2327   if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
2328        kMultipleClickTimeSec) &&
2329       (!OutsideMultiClickRadius(last_mouse_pos_, last_click_pos_)) &&
2330       (button_type == last_button_type_)) {
2331     ++click_count_;
2332   } else {
2333     click_count_ = 1;
2334     last_button_type_ = button_type;
2335   }
2336 }
2337
2338 void EventSender::InitMouseWheelEvent(gin::Arguments* args,
2339                                       bool continuous,
2340                                       WebMouseWheelEvent* event) {
2341   // Force a layout here just to make sure every position has been
2342   // determined before we send events (as well as all the other methods
2343   // that send an event do).
2344   if (force_layout_on_events_)
2345     view_->layout();
2346
2347   double horizontal;
2348   if (!args->GetNext(&horizontal)) {
2349     args->ThrowError();
2350     return;
2351   }
2352   double vertical;
2353   if (!args->GetNext(&vertical)) {
2354     args->ThrowError();
2355     return;
2356   }
2357
2358   bool paged = false;
2359   bool has_precise_scrolling_deltas = false;
2360   int modifiers = 0;
2361   bool can_scroll = true;
2362   if (!args->PeekNext().IsEmpty()) {
2363     args->GetNext(&paged);
2364     if (!args->PeekNext().IsEmpty()) {
2365       args->GetNext(&has_precise_scrolling_deltas);
2366       if (!args->PeekNext().IsEmpty()) {
2367         v8::Local<v8::Value> value;
2368         args->GetNext(&value);
2369         modifiers = GetKeyModifiersFromV8(args->isolate(), value);
2370         if (!args->PeekNext().IsEmpty())
2371           args->GetNext(&can_scroll);
2372       }
2373     }
2374   }
2375
2376   InitMouseEvent(WebInputEvent::MouseWheel,
2377                  pressed_button_,
2378                  last_mouse_pos_,
2379                  GetCurrentEventTimeSec(),
2380                  click_count_,
2381                  modifiers,
2382                  event);
2383   event->wheelTicksX = static_cast<float>(horizontal);
2384   event->wheelTicksY = static_cast<float>(vertical);
2385   event->deltaX = event->wheelTicksX;
2386   event->deltaY = event->wheelTicksY;
2387   event->scrollByPage = paged;
2388   event->hasPreciseScrollingDeltas = has_precise_scrolling_deltas;
2389   event->canScroll = can_scroll;
2390   if (continuous) {
2391     event->wheelTicksX /= kScrollbarPixelsPerTick;
2392     event->wheelTicksY /= kScrollbarPixelsPerTick;
2393   } else {
2394     event->deltaX *= kScrollbarPixelsPerTick;
2395     event->deltaY *= kScrollbarPixelsPerTick;
2396   }
2397 }
2398
2399 // Radius fields radius_x and radius_y should eventually be moved to
2400 // WebPointerProperties.
2401 // TODO(e_hakkinen): Drop radius_{x,y}_pointer parameters once that happens.
2402 void EventSender::InitPointerProperties(gin::Arguments* args,
2403                                         blink::WebPointerProperties* e,
2404                                         float* radius_x_pointer,
2405                                         float* radius_y_pointer) {
2406   if (!args->PeekNext().IsEmpty()) {
2407     double radius_x;
2408     if (!args->GetNext(&radius_x)) {
2409       args->ThrowError();
2410       return;
2411     }
2412
2413     double radius_y = radius_x;
2414     if (!args->PeekNext().IsEmpty()) {
2415       if (!args->GetNext(&radius_y)) {
2416         args->ThrowError();
2417         return;
2418       }
2419     }
2420
2421     *radius_x_pointer = static_cast<float>(radius_x);
2422     *radius_y_pointer = static_cast<float>(radius_y);
2423   }
2424
2425   if (!args->PeekNext().IsEmpty()) {
2426     double force;
2427     if (!args->GetNext(&force)) {
2428       args->ThrowError();
2429       return;
2430     }
2431     e->force = static_cast<float>(force);
2432   }
2433
2434   if (!args->PeekNext().IsEmpty()) {
2435     int tiltX, tiltY;
2436     if (!args->GetNext(&tiltX) || !args->GetNext(&tiltY)) {
2437       args->ThrowError();
2438       return;
2439     }
2440     e->tiltX = tiltX;
2441     e->tiltY = tiltY;
2442   }
2443
2444   if (!args->PeekNext().IsEmpty()) {
2445     std::string pointer_type_string;
2446     if (!args->GetNext(&pointer_type_string)) {
2447       args->ThrowError();
2448       return;
2449     }
2450     if (pointer_type_string == kPointerTypeStringUnknown) {
2451       e->pointerType = WebMouseEvent::PointerTypeUnknown;
2452     } else if (pointer_type_string == kPointerTypeStringMouse) {
2453       e->pointerType = WebMouseEvent::PointerTypeMouse;
2454     } else if (pointer_type_string == kPointerTypeStringPen) {
2455       e->pointerType = WebMouseEvent::PointerTypePen;
2456     } else if (pointer_type_string == kPointerTypeStringTouch) {
2457       e->pointerType = WebMouseEvent::PointerTypeTouch;
2458     } else {
2459       args->ThrowError();
2460       return;
2461     }
2462   }
2463 }
2464
2465 void EventSender::FinishDragAndDrop(const WebMouseEvent& e,
2466                                      blink::WebDragOperation drag_effect) {
2467   WebPoint client_point(e.x, e.y);
2468   WebPoint screen_point(e.globalX, e.globalY);
2469   current_drag_effect_ = drag_effect;
2470   if (current_drag_effect_) {
2471     // Specifically pass any keyboard modifiers to the drop method. This allows
2472     // tests to control the drop type (i.e. copy or move).
2473     view_->dragTargetDrop(client_point, screen_point, e.modifiers);
2474   } else {
2475     view_->dragTargetDragLeave();
2476   }
2477   view_->dragSourceEndedAt(client_point, screen_point, current_drag_effect_);
2478   view_->dragSourceSystemDragEnded();
2479
2480   current_drag_data_.reset();
2481 }
2482
2483 void EventSender::DoMouseUp(const WebMouseEvent& e) {
2484   HandleInputEventOnViewOrPopup(e);
2485
2486   pressed_button_ = WebMouseEvent::ButtonNone;
2487   last_click_time_sec_ = e.timeStampSeconds;
2488   last_click_pos_ = last_mouse_pos_;
2489
2490   // If we're in a drag operation, complete it.
2491   if (current_drag_data_.isNull())
2492     return;
2493
2494   WebPoint client_point(e.x, e.y);
2495   WebPoint screen_point(e.globalX, e.globalY);
2496   FinishDragAndDrop(
2497       e,
2498       view_->dragTargetDragOver(
2499           client_point,
2500           screen_point,
2501           current_drag_effects_allowed_,
2502           e.modifiers));
2503 }
2504
2505 void EventSender::DoMouseMove(const WebMouseEvent& e) {
2506   last_mouse_pos_ = WebPoint(e.x, e.y);
2507
2508   HandleInputEventOnViewOrPopup(e);
2509
2510   if (pressed_button_ == WebMouseEvent::ButtonNone ||
2511       current_drag_data_.isNull()) {
2512     return;
2513   }
2514
2515   WebPoint client_point(e.x, e.y);
2516   WebPoint screen_point(e.globalX, e.globalY);
2517   current_drag_effect_ = view_->dragTargetDragOver(
2518       client_point, screen_point, current_drag_effects_allowed_, e.modifiers);
2519 }
2520
2521 void EventSender::ReplaySavedEvents() {
2522   replaying_saved_events_ = true;
2523   while (!mouse_event_queue_.empty()) {
2524     SavedEvent e = mouse_event_queue_.front();
2525     mouse_event_queue_.pop_front();
2526
2527     switch (e.type) {
2528       case SavedEvent::TYPE_MOUSE_MOVE: {
2529         WebMouseEvent event;
2530         InitMouseEvent(WebInputEvent::MouseMove,
2531                        pressed_button_,
2532                        e.pos,
2533                        GetCurrentEventTimeSec(),
2534                        click_count_,
2535                        e.modifiers,
2536                        &event);
2537         DoMouseMove(event);
2538         break;
2539       }
2540       case SavedEvent::TYPE_LEAP_FORWARD:
2541         DoLeapForward(e.milliseconds);
2542         break;
2543       case SavedEvent::TYPE_MOUSE_UP: {
2544         WebMouseEvent event;
2545         InitMouseEvent(WebInputEvent::MouseUp,
2546                        e.button_type,
2547                        last_mouse_pos_,
2548                        GetCurrentEventTimeSec(),
2549                        click_count_,
2550                        e.modifiers,
2551                        &event);
2552         DoMouseUp(event);
2553         break;
2554       }
2555       default:
2556         NOTREACHED();
2557     }
2558   }
2559
2560   replaying_saved_events_ = false;
2561 }
2562
2563 bool EventSender::HandleInputEventOnViewOrPopup(const WebInputEvent& event) {
2564   if (WebPagePopup* popup = view_->pagePopup()) {
2565     if (!WebInputEvent::isKeyboardEventType(event.type))
2566       return popup->handleInputEvent(event);
2567   }
2568   return view_->handleInputEvent(event);
2569 }
2570
2571 }  // namespace test_runner