Do touch adjustment on GestureTapDown
[WebKit-https.git] / Tools / DumpRenderTree / chromium / TestRunner / EventSender.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 // This file contains the definition for EventSender.
32 //
33 // Some notes about drag and drop handling:
34 // Windows drag and drop goes through a system call to doDragDrop. At that
35 // point, program control is given to Windows which then periodically makes
36 // callbacks into the webview. This won't work for layout tests, so instead,
37 // we queue up all the mouse move and mouse up events. When the test tries to
38 // start a drag (by calling EvenSendingController::doDragDrop), we take the
39 // events in the queue and replay them.
40 // The behavior of queuing events and replaying them can be disabled by a
41 // layout test by setting eventSender.dragMode to false.
42
43 #include "config.h"
44 #include "EventSender.h"
45
46 #include "TestDelegate.h"
47 #include "WebContextMenuData.h"
48 #include "WebDragOperation.h"
49 #include "WebTouchPoint.h"
50 #include "WebView.h"
51 #include "platform/WebDragData.h"
52 #include "platform/WebPoint.h"
53 #include "platform/WebString.h"
54 #include "webkit/support/webkit_support.h"
55 #include <wtf/Deque.h>
56 #include <wtf/StringExtras.h>
57
58 #if OS(WINDOWS)
59 #include "win/WebInputEventFactory.h"
60 #endif
61
62 // FIXME: layout before each event?
63
64 using namespace std;
65 using namespace WebKit;
66
67 WebPoint EventSender::lastMousePos;
68 WebMouseEvent::Button EventSender::pressedButton = WebMouseEvent::ButtonNone;
69 WebMouseEvent::Button EventSender::lastButtonType = WebMouseEvent::ButtonNone;
70
71 struct SavedEvent {
72     enum SavedEventType {
73         Unspecified,
74         MouseUp,
75         MouseMove,
76         LeapForward
77     };
78
79     SavedEventType type;
80     WebMouseEvent::Button buttonType; // For MouseUp.
81     WebPoint pos; // For MouseMove.
82     int milliseconds; // For LeapForward.
83
84     SavedEvent()
85         : type(Unspecified)
86         , buttonType(WebMouseEvent::ButtonNone)
87         , milliseconds(0) { }
88 };
89
90 static WebDragData currentDragData;
91 static WebDragOperation currentDragEffect;
92 static WebDragOperationsMask currentDragEffectsAllowed;
93 static bool replayingSavedEvents = false;
94 static Deque<SavedEvent> mouseEventQueue;
95 static int touchModifiers;
96 static Vector<WebTouchPoint> touchPoints;
97
98 // Time and place of the last mouse up event.
99 static double lastClickTimeSec = 0;
100 static WebPoint lastClickPos;
101 static int clickCount = 0;
102
103 // maximum distance (in space and time) for a mouse click
104 // to register as a double or triple click
105 static const double multipleClickTimeSec = 1;
106 static const int multipleClickRadiusPixels = 5;
107
108 // How much we should scroll per event - the value here is chosen to
109 // match the WebKit impl and layout test results.
110 static const float scrollbarPixelsPerTick = 40.0f;
111
112 inline bool outsideMultiClickRadius(const WebPoint& a, const WebPoint& b)
113 {
114     return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) >
115         multipleClickRadiusPixels * multipleClickRadiusPixels;
116 }
117
118 // Used to offset the time the event hander things an event happened. This is
119 // done so tests can run without a delay, but bypass checks that are time
120 // dependent (e.g., dragging has a timeout vs selection).
121 static uint32 timeOffsetMs = 0;
122
123 static double getCurrentEventTimeSec()
124 {
125     return (webkit_support::GetCurrentTimeInMillisecond() + timeOffsetMs) / 1000.0;
126 }
127
128 static void advanceEventTime(int32_t deltaMs)
129 {
130     timeOffsetMs += deltaMs;
131 }
132
133 static void initMouseEvent(WebInputEvent::Type t, WebMouseEvent::Button b,
134                            const WebPoint& pos, WebMouseEvent* e)
135 {
136     e->type = t;
137     e->button = b;
138     e->modifiers = 0;
139     e->x = pos.x;
140     e->y = pos.y;
141     e->globalX = pos.x;
142     e->globalY = pos.y;
143     e->timeStampSeconds = getCurrentEventTimeSec();
144     e->clickCount = clickCount;
145 }
146
147 // Returns true if the specified key is the system key.
148 static bool applyKeyModifier(const string& modifierName, WebInputEvent* event)
149 {
150     bool isSystemKey = false;
151     const char* characters = modifierName.c_str();
152     if (!strcmp(characters, "ctrlKey")
153 #if !OS(MAC_OS_X)
154         || !strcmp(characters, "addSelectionKey")
155 #endif
156         ) {
157         event->modifiers |= WebInputEvent::ControlKey;
158     } else if (!strcmp(characters, "shiftKey") || !strcmp(characters, "rangeSelectionKey"))
159         event->modifiers |= WebInputEvent::ShiftKey;
160     else if (!strcmp(characters, "altKey")) {
161         event->modifiers |= WebInputEvent::AltKey;
162 #if !OS(MAC_OS_X)
163         // On Windows all keys with Alt modifier will be marked as system key.
164         // We keep the same behavior on Linux and everywhere non-Mac, see:
165         // WebKit/chromium/src/gtk/WebInputEventFactory.cpp
166         // If we want to change this behavior on Linux, this piece of code must be
167         // kept in sync with the related code in above file.
168         isSystemKey = true;
169 #endif
170 #if OS(MAC_OS_X)
171     } else if (!strcmp(characters, "metaKey") || !strcmp(characters, "addSelectionKey")) {
172         event->modifiers |= WebInputEvent::MetaKey;
173         // On Mac only command key presses are marked as system key.
174         // See the related code in: WebKit/chromium/src/mac/WebInputEventFactory.cpp
175         // It must be kept in sync with the related code in above file.
176         isSystemKey = true;
177 #else
178     } else if (!strcmp(characters, "metaKey")) {
179         event->modifiers |= WebInputEvent::MetaKey;
180 #endif
181     }
182     return isSystemKey;
183 }
184
185 static bool applyKeyModifiers(const CppVariant* argument, WebInputEvent* event)
186 {
187     bool isSystemKey = false;
188     if (argument->isObject()) {
189         Vector<string> modifiers = argument->toStringVector();
190         for (Vector<string>::const_iterator i = modifiers.begin(); i != modifiers.end(); ++i)
191             isSystemKey |= applyKeyModifier(*i, event);
192     } else if (argument->isString())
193         isSystemKey = applyKeyModifier(argument->toString(), event);
194     return isSystemKey;
195 }
196
197 // Get the edit command corresponding to a keyboard event.
198 // Returns true if the specified event corresponds to an edit command, the name
199 // of the edit command will be stored in |*name|.
200 bool getEditCommand(const WebKeyboardEvent& event, string* name)
201 {
202 #if OS(MAC_OS_X)
203     // We only cares about Left,Right,Up,Down keys with Command or Command+Shift
204     // modifiers. These key events correspond to some special movement and
205     // selection editor commands, and was supposed to be handled in
206     // WebKit/chromium/src/EditorClientImpl.cpp. But these keys will be marked
207     // as system key, which prevents them from being handled. Thus they must be
208     // handled specially.
209     if ((event.modifiers & ~WebKeyboardEvent::ShiftKey) != WebKeyboardEvent::MetaKey)
210         return false;
211
212     switch (event.windowsKeyCode) {
213     case webkit_support::VKEY_LEFT:
214         *name = "MoveToBeginningOfLine";
215         break;
216     case webkit_support::VKEY_RIGHT:
217         *name = "MoveToEndOfLine";
218         break;
219     case webkit_support::VKEY_UP:
220         *name = "MoveToBeginningOfDocument";
221         break;
222     case webkit_support::VKEY_DOWN:
223         *name = "MoveToEndOfDocument";
224         break;
225     default:
226         return false;
227     }
228
229     if (event.modifiers & WebKeyboardEvent::ShiftKey)
230         name->append("AndModifySelection");
231
232     return true;
233 #else
234     return false;
235 #endif
236 }
237
238 // Key event location code introduced in DOM Level 3.
239 // See also: http://www.w3.org/TR/DOM-Level-3-Events/#events-keyboardevents
240 enum KeyLocationCode {
241     DOMKeyLocationStandard      = 0x00,
242     DOMKeyLocationLeft          = 0x01,
243     DOMKeyLocationRight         = 0x02,
244     DOMKeyLocationNumpad        = 0x03
245 };
246
247 EventSender::EventSender()
248     : m_delegate(0)
249 {
250     // Initialize the map that associates methods of this class with the names
251     // they will use when called by JavaScript. The actual binding of those
252     // names to their methods will be done by calling bindToJavaScript() (defined
253     // by CppBoundClass, the parent to EventSender).
254     bindMethod("addTouchPoint", &EventSender::addTouchPoint);
255     bindMethod("beginDragWithFiles", &EventSender::beginDragWithFiles);
256     bindMethod("cancelTouchPoint", &EventSender::cancelTouchPoint);
257     bindMethod("clearKillRing", &EventSender::clearKillRing);
258     bindMethod("clearTouchPoints", &EventSender::clearTouchPoints);
259     bindMethod("contextClick", &EventSender::contextClick);
260     bindMethod("continuousMouseScrollBy", &EventSender::continuousMouseScrollBy);
261     bindMethod("dispatchMessage", &EventSender::dispatchMessage);
262     bindMethod("dumpFilenameBeingDragged", &EventSender::dumpFilenameBeingDragged);
263     bindMethod("enableDOMUIEventLogging", &EventSender::enableDOMUIEventLogging);
264     bindMethod("fireKeyboardEventsToElement", &EventSender::fireKeyboardEventsToElement);
265     bindMethod("keyDown", &EventSender::keyDown);
266     bindMethod("leapForward", &EventSender::leapForward);
267     bindMethod("mouseDown", &EventSender::mouseDown);
268     bindMethod("mouseMoveTo", &EventSender::mouseMoveTo);
269     bindMethod("mouseScrollBy", &EventSender::mouseScrollBy);
270     bindMethod("mouseUp", &EventSender::mouseUp);
271     bindMethod("releaseTouchPoint", &EventSender::releaseTouchPoint);
272     bindMethod("scheduleAsynchronousClick", &EventSender::scheduleAsynchronousClick);
273     bindMethod("scheduleAsynchronousKeyDown", &EventSender::scheduleAsynchronousKeyDown);
274     bindMethod("setTouchModifier", &EventSender::setTouchModifier);
275     bindMethod("textZoomIn", &EventSender::textZoomIn);
276     bindMethod("textZoomOut", &EventSender::textZoomOut);
277     bindMethod("touchCancel", &EventSender::touchCancel);
278     bindMethod("touchEnd", &EventSender::touchEnd);
279     bindMethod("touchMove", &EventSender::touchMove);
280     bindMethod("touchStart", &EventSender::touchStart);
281     bindMethod("updateTouchPoint", &EventSender::updateTouchPoint);
282     bindMethod("gestureFlingCancel", &EventSender::gestureFlingCancel);
283     bindMethod("gestureFlingStart", &EventSender::gestureFlingStart);
284     bindMethod("gestureScrollBegin", &EventSender::gestureScrollBegin);
285     bindMethod("gestureScrollEnd", &EventSender::gestureScrollEnd);
286     bindMethod("gestureScrollFirstPoint", &EventSender::gestureScrollFirstPoint);
287     bindMethod("gestureScrollUpdate", &EventSender::gestureScrollUpdate);
288     bindMethod("gestureTap", &EventSender::gestureTap);
289     bindMethod("gestureTapDown", &EventSender::gestureTapDown);
290     bindMethod("gestureTapCancel", &EventSender::gestureTapCancel);
291     bindMethod("gestureLongPress", &EventSender::gestureLongPress);
292     bindMethod("gestureTwoFingerTap", &EventSender::gestureTwoFingerTap);
293     bindMethod("zoomPageIn", &EventSender::zoomPageIn);
294     bindMethod("zoomPageOut", &EventSender::zoomPageOut);
295     bindMethod("scalePageBy", &EventSender::scalePageBy);
296
297     // When set to true (the default value), we batch mouse move and mouse up
298     // events so we can simulate drag & drop.
299     bindProperty("dragMode", &dragMode);
300 #if OS(WINDOWS)
301     bindProperty("WM_KEYDOWN", &wmKeyDown);
302     bindProperty("WM_KEYUP", &wmKeyUp);
303     bindProperty("WM_CHAR", &wmChar);
304     bindProperty("WM_DEADCHAR", &wmDeadChar);
305     bindProperty("WM_SYSKEYDOWN", &wmSysKeyDown);
306     bindProperty("WM_SYSKEYUP", &wmSysKeyUp);
307     bindProperty("WM_SYSCHAR", &wmSysChar);
308     bindProperty("WM_SYSDEADCHAR", &wmSysDeadChar);
309 #endif
310 }
311
312 void EventSender::reset()
313 {
314     // The test should have finished a drag and the mouse button state.
315     ASSERT(currentDragData.isNull());
316     currentDragData.reset();
317     currentDragEffect = WebKit::WebDragOperationNone;
318     currentDragEffectsAllowed = WebKit::WebDragOperationNone;
319     pressedButton = WebMouseEvent::ButtonNone;
320     dragMode.set(true);
321 #if OS(WINDOWS)
322     wmKeyDown.set(WM_KEYDOWN);
323     wmKeyUp.set(WM_KEYUP);
324     wmChar.set(WM_CHAR);
325     wmDeadChar.set(WM_DEADCHAR);
326     wmSysKeyDown.set(WM_SYSKEYDOWN);
327     wmSysKeyUp.set(WM_SYSKEYUP);
328     wmSysChar.set(WM_SYSCHAR);
329     wmSysDeadChar.set(WM_SYSDEADCHAR);
330 #endif
331     lastMousePos = WebPoint(0, 0);
332     lastClickTimeSec = 0;
333     lastClickPos = WebPoint(0, 0);
334     clickCount = 0;
335     lastButtonType = WebMouseEvent::ButtonNone;
336     timeOffsetMs = 0;
337     touchModifiers = 0;
338     touchPoints.clear();
339     m_taskList.revokeAll();
340     m_currentGestureLocation = WebPoint(0, 0);
341 }
342
343 void EventSender::doDragDrop(const WebDragData& dragData, WebDragOperationsMask mask)
344 {
345     WebMouseEvent event;
346     initMouseEvent(WebInputEvent::MouseDown, pressedButton, lastMousePos, &event);
347     WebPoint clientPoint(event.x, event.y);
348     WebPoint screenPoint(event.globalX, event.globalY);
349     currentDragData = dragData;
350     currentDragEffectsAllowed = mask;
351     currentDragEffect = webview()->dragTargetDragEnter(dragData, clientPoint, screenPoint, currentDragEffectsAllowed, 0);
352
353     // Finish processing events.
354     replaySavedEvents();
355 }
356
357 void EventSender::dumpFilenameBeingDragged(const CppArgumentList&, CppVariant*)
358 {
359     WebString filename;
360     WebVector<WebDragData::Item> items = currentDragData.items();
361     for (size_t i = 0; i < items.size(); ++i) {
362         if (items[i].storageType == WebDragData::Item::StorageTypeBinaryData) {
363             filename = items[i].title;
364             break;
365         }
366     }
367     printf("Filename being dragged: %s\n", filename.utf8().data());
368 }
369
370 WebMouseEvent::Button EventSender::getButtonTypeFromButtonNumber(int buttonCode)
371 {
372     if (!buttonCode)
373         return WebMouseEvent::ButtonLeft;
374     if (buttonCode == 2)
375         return WebMouseEvent::ButtonRight;
376     return WebMouseEvent::ButtonMiddle;
377 }
378
379 int EventSender::getButtonNumberFromSingleArg(const CppArgumentList& arguments)
380 {
381     int buttonCode = 0;
382     if (arguments.size() > 0 && arguments[0].isNumber())
383         buttonCode = arguments[0].toInt32();
384     return buttonCode;
385 }
386
387 void EventSender::updateClickCountForButton(WebMouseEvent::Button buttonType)
388 {
389     if ((getCurrentEventTimeSec() - lastClickTimeSec < multipleClickTimeSec)
390         && (!outsideMultiClickRadius(lastMousePos, lastClickPos))
391         && (buttonType == lastButtonType))
392         ++clickCount;
393     else {
394         clickCount = 1;
395         lastButtonType = buttonType;
396     }
397 }
398
399 //
400 // Implemented javascript methods.
401 //
402
403 void EventSender::mouseDown(const CppArgumentList& arguments, CppVariant* result)
404 {
405     if (result) // Could be 0 if invoked asynchronously.
406         result->setNull();
407
408     webview()->layout();
409
410     int buttonNumber = getButtonNumberFromSingleArg(arguments);
411     ASSERT(buttonNumber != -1);
412
413     WebMouseEvent::Button buttonType = getButtonTypeFromButtonNumber(buttonNumber);
414
415     updateClickCountForButton(buttonType);
416
417     WebMouseEvent event;
418     pressedButton = buttonType;
419     initMouseEvent(WebInputEvent::MouseDown, buttonType, lastMousePos, &event);
420     if (arguments.size() >= 2 && (arguments[1].isObject() || arguments[1].isString()))
421         applyKeyModifiers(&(arguments[1]), &event);
422     webview()->handleInputEvent(event);
423 }
424
425 void EventSender::mouseUp(const CppArgumentList& arguments, CppVariant* result)
426 {
427     if (result) // Could be 0 if invoked asynchronously.
428         result->setNull();
429
430     webview()->layout();
431
432     int buttonNumber = getButtonNumberFromSingleArg(arguments);
433     ASSERT(buttonNumber != -1);
434
435     WebMouseEvent::Button buttonType = getButtonTypeFromButtonNumber(buttonNumber);
436
437     if (isDragMode() && !replayingSavedEvents) {
438         SavedEvent savedEvent;
439         savedEvent.type = SavedEvent::MouseUp;
440         savedEvent.buttonType = buttonType;
441         mouseEventQueue.append(savedEvent);
442         replaySavedEvents();
443     } else {
444         WebMouseEvent event;
445         initMouseEvent(WebInputEvent::MouseUp, buttonType, lastMousePos, &event);
446         if (arguments.size() >= 2 && (arguments[1].isObject() || arguments[1].isString()))
447             applyKeyModifiers(&(arguments[1]), &event);
448         doMouseUp(event);
449     }
450 }
451
452 void EventSender::doMouseUp(const WebMouseEvent& e)
453 {
454     webview()->handleInputEvent(e);
455
456     pressedButton = WebMouseEvent::ButtonNone;
457     lastClickTimeSec = e.timeStampSeconds;
458     lastClickPos = lastMousePos;
459
460     // If we're in a drag operation, complete it.
461     if (currentDragData.isNull())
462         return;
463     WebPoint clientPoint(e.x, e.y);
464     WebPoint screenPoint(e.globalX, e.globalY);
465
466     currentDragEffect = webview()->dragTargetDragOver(clientPoint, screenPoint, currentDragEffectsAllowed, 0);
467     if (currentDragEffect)
468         webview()->dragTargetDrop(clientPoint, screenPoint, 0);
469     else
470         webview()->dragTargetDragLeave();
471     webview()->dragSourceEndedAt(clientPoint, screenPoint, currentDragEffect);
472     webview()->dragSourceSystemDragEnded();
473
474     currentDragData.reset();
475 }
476
477 void EventSender::mouseMoveTo(const CppArgumentList& arguments, CppVariant* result)
478 {
479     result->setNull();
480
481     if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
482         return;
483     webview()->layout();
484
485     WebPoint mousePos(arguments[0].toInt32(), arguments[1].toInt32());
486
487     if (isDragMode() && pressedButton == WebMouseEvent::ButtonLeft && !replayingSavedEvents) {
488         SavedEvent savedEvent;
489         savedEvent.type = SavedEvent::MouseMove;
490         savedEvent.pos = mousePos;
491         mouseEventQueue.append(savedEvent);
492     } else {
493         WebMouseEvent event;
494         initMouseEvent(WebInputEvent::MouseMove, pressedButton, mousePos, &event);
495         doMouseMove(event);
496     }
497 }
498
499 void EventSender::doMouseMove(const WebMouseEvent& e)
500 {
501     lastMousePos = WebPoint(e.x, e.y);
502
503     webview()->handleInputEvent(e);
504
505     if (pressedButton == WebMouseEvent::ButtonNone || currentDragData.isNull())
506         return;
507     WebPoint clientPoint(e.x, e.y);
508     WebPoint screenPoint(e.globalX, e.globalY);
509     currentDragEffect = webview()->dragTargetDragOver(clientPoint, screenPoint, currentDragEffectsAllowed, 0);
510 }
511
512 void EventSender::keyDown(const CppArgumentList& arguments, CppVariant* result)
513 {
514     if (result)
515         result->setNull();
516     if (arguments.size() < 1 || !arguments[0].isString())
517         return;
518     bool generateChar = false;
519
520     // FIXME: I'm not exactly sure how we should convert the string to a key
521     // event. This seems to work in the cases I tested.
522     // FIXME: Should we also generate a KEY_UP?
523     string codeStr = arguments[0].toString();
524
525     // Convert \n -> VK_RETURN. Some layout tests use \n to mean "Enter", when
526     // Windows uses \r for "Enter".
527     int code = 0;
528     int text = 0;
529     bool needsShiftKeyModifier = false;
530     if ("\n" == codeStr) {
531         generateChar = true;
532         text = code = webkit_support::VKEY_RETURN;
533     } else if ("rightArrow" == codeStr)
534         code = webkit_support::VKEY_RIGHT;
535     else if ("downArrow" == codeStr)
536         code = webkit_support::VKEY_DOWN;
537     else if ("leftArrow" == codeStr)
538         code = webkit_support::VKEY_LEFT;
539     else if ("upArrow" == codeStr)
540         code = webkit_support::VKEY_UP;
541     else if ("insert" == codeStr)
542         code = webkit_support::VKEY_INSERT;
543     else if ("delete" == codeStr)
544         code = webkit_support::VKEY_DELETE;
545     else if ("pageUp" == codeStr)
546         code = webkit_support::VKEY_PRIOR;
547     else if ("pageDown" == codeStr)
548         code = webkit_support::VKEY_NEXT;
549     else if ("home" == codeStr)
550         code = webkit_support::VKEY_HOME;
551     else if ("end" == codeStr)
552         code = webkit_support::VKEY_END;
553     else if ("printScreen" == codeStr)
554         code = webkit_support::VKEY_SNAPSHOT;
555     else if ("menu" == codeStr)
556         // FIXME: Change this to webkit_support::VKEY_APPS.
557         code = 0x5D;
558     else if ("leftControl" == codeStr)
559         // FIXME: Change this to webkit_support::VKEY_LCONTROL.
560         code = 0xA2;
561     else if ("rightControl" == codeStr)
562         // FIXME: Change this to webkit_support::VKEY_RCONTROL.
563         code = 0xA3;
564     else if ("leftShift" == codeStr)
565         // FIXME: Change this to webkit_support::VKEY_LSHIFT.
566         code = 0xA0;
567     else if ("rightShift" == codeStr)
568         // FIXME: Change this to webkit_support::VKEY_RSHIFT.
569         code = 0xA1;
570     else if ("leftAlt" == codeStr)
571         // FIXME: Change this to webkit_support::VKEY_LMENU.
572         code = 0xA4;
573     else if ("rightAlt" == codeStr)
574         // FIXME: Change this to webkit_support::VKEY_RMENU.
575         code = 0xA5;
576     else {
577         // Compare the input string with the function-key names defined by the
578         // DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key
579         // name, set its key code.
580         for (int i = 1; i <= 24; ++i) {
581             char functionChars[10];
582             snprintf(functionChars, 10, "F%d", i);
583             string functionKeyName(functionChars);
584             if (functionKeyName == codeStr) {
585                 code = webkit_support::VKEY_F1 + (i - 1);
586                 break;
587             }
588         }
589         if (!code) {
590             WebString webCodeStr = WebString::fromUTF8(codeStr.data(), codeStr.size());
591             ASSERT(webCodeStr.length() == 1);
592             text = code = webCodeStr.data()[0];
593             needsShiftKeyModifier = needsShiftModifier(code);
594             if ((code & 0xFF) >= 'a' && (code & 0xFF) <= 'z')
595                 code -= 'a' - 'A';
596             generateChar = true;
597         }
598     }
599
600     // For one generated keyboard event, we need to generate a keyDown/keyUp
601     // pair; refer to EventSender.cpp in Tools/DumpRenderTree/win.
602     // On Windows, we might also need to generate a char event to mimic the
603     // Windows event flow; on other platforms we create a merged event and test
604     // the event flow that that platform provides.
605     WebKeyboardEvent eventDown, eventChar, eventUp;
606     eventDown.type = WebInputEvent::RawKeyDown;
607     eventDown.modifiers = 0;
608     eventDown.windowsKeyCode = code;
609 #if OS(LINUX) && USE(GTK)
610     eventDown.nativeKeyCode = webkit_support::NativeKeyCodeForWindowsKeyCode(code, needsShiftKeyModifier);
611 #endif
612
613     if (generateChar) {
614         eventDown.text[0] = text;
615         eventDown.unmodifiedText[0] = text;
616     }
617     eventDown.setKeyIdentifierFromWindowsKeyCode();
618
619     if (arguments.size() >= 2 && (arguments[1].isObject() || arguments[1].isString()))
620         eventDown.isSystemKey = applyKeyModifiers(&(arguments[1]), &eventDown);
621
622     if (needsShiftKeyModifier)
623         eventDown.modifiers |= WebInputEvent::ShiftKey;
624
625     // See if KeyLocation argument is given.
626     if (arguments.size() >= 3 && arguments[2].isNumber()) {
627         int location = arguments[2].toInt32();
628         if (location == DOMKeyLocationNumpad)
629             eventDown.modifiers |= WebInputEvent::IsKeyPad;
630     }
631
632     eventChar = eventUp = eventDown;
633     eventUp.type = WebInputEvent::KeyUp;
634     // EventSender.m forces a layout here, with at least one
635     // test (fast/forms/focus-control-to-page.html) relying on this.
636     webview()->layout();
637
638     // In the browser, if a keyboard event corresponds to an editor command,
639     // the command will be dispatched to the renderer just before dispatching
640     // the keyboard event, and then it will be executed in the
641     // RenderView::handleCurrentKeyboardEvent() method, which is called from
642     // third_party/WebKit/Source/WebKit/chromium/src/EditorClientImpl.cpp.
643     // We just simulate the same behavior here.
644     string editCommand;
645     if (getEditCommand(eventDown, &editCommand))
646         m_delegate->setEditCommand(editCommand, "");
647
648     webview()->handleInputEvent(eventDown);
649
650     m_delegate->clearEditCommand();
651
652     if (generateChar) {
653         eventChar.type = WebInputEvent::Char;
654         eventChar.keyIdentifier[0] = '\0';
655         webview()->handleInputEvent(eventChar);
656     }
657
658     webview()->handleInputEvent(eventUp);
659 }
660
661 void EventSender::dispatchMessage(const CppArgumentList& arguments, CppVariant* result)
662 {
663     result->setNull();
664
665 #if OS(WINDOWS)
666     if (arguments.size() == 3) {
667         // Grab the message id to see if we need to dispatch it.
668         int msg = arguments[0].toInt32();
669
670         // WebKit's version of this function stuffs a MSG struct and uses
671         // TranslateMessage and DispatchMessage. We use a WebKeyboardEvent, which
672         // doesn't need to receive the DeadChar and SysDeadChar messages.
673         if (msg == WM_DEADCHAR || msg == WM_SYSDEADCHAR)
674             return;
675
676         webview()->layout();
677
678         unsigned long lparam = static_cast<unsigned long>(arguments[2].toDouble());
679         webview()->handleInputEvent(WebInputEventFactory::keyboardEvent(0, msg, arguments[1].toInt32(), lparam));
680     } else
681         ASSERT_NOT_REACHED();
682 #endif
683 }
684
685 bool EventSender::needsShiftModifier(int keyCode)
686 {
687     // If code is an uppercase letter, assign a SHIFT key to
688     // eventDown.modifier, this logic comes from
689     // Tools/DumpRenderTree/win/EventSender.cpp
690     return (keyCode & 0xFF) >= 'A' && (keyCode & 0xFF) <= 'Z';
691 }
692
693 void EventSender::leapForward(const CppArgumentList& arguments, CppVariant* result)
694 {
695     result->setNull();
696
697     if (arguments.size() < 1 || !arguments[0].isNumber())
698         return;
699
700     int milliseconds = arguments[0].toInt32();
701     if (isDragMode() && pressedButton == WebMouseEvent::ButtonLeft && !replayingSavedEvents) {
702         SavedEvent savedEvent;
703         savedEvent.type = SavedEvent::LeapForward;
704         savedEvent.milliseconds = milliseconds;
705         mouseEventQueue.append(savedEvent);
706     } else
707         doLeapForward(milliseconds);
708 }
709
710 void EventSender::doLeapForward(int milliseconds)
711 {
712     advanceEventTime(milliseconds);
713 }
714
715 // Apple's port of WebKit zooms by a factor of 1.2 (see
716 // WebKit/WebView/WebView.mm)
717 void EventSender::textZoomIn(const CppArgumentList&, CppVariant* result)
718 {
719     webview()->setZoomLevel(true, webview()->zoomLevel() + 1);
720     result->setNull();
721 }
722
723 void EventSender::textZoomOut(const CppArgumentList&, CppVariant* result)
724 {
725     webview()->setZoomLevel(true, webview()->zoomLevel() - 1);
726     result->setNull();
727 }
728
729 void EventSender::zoomPageIn(const CppArgumentList&, CppVariant* result)
730 {
731     webview()->setZoomLevel(false, webview()->zoomLevel() + 1);
732     result->setNull();
733 }
734
735 void EventSender::zoomPageOut(const CppArgumentList&, CppVariant* result)
736 {
737     webview()->setZoomLevel(false, webview()->zoomLevel() - 1);
738     result->setNull();
739 }
740
741 void EventSender::scalePageBy(const CppArgumentList& arguments, CppVariant* result)
742 {
743     if (arguments.size() < 3 || !arguments[0].isNumber() || !arguments[1].isNumber() || !arguments[2].isNumber())
744         return;
745
746     float scaleFactor = static_cast<float>(arguments[0].toDouble());
747     int x = arguments[1].toInt32();
748     int y = arguments[2].toInt32();
749     webview()->setPageScaleFactor(scaleFactor, WebPoint(x, y));
750     result->setNull();
751 }
752
753 void EventSender::mouseScrollBy(const CppArgumentList& arguments, CppVariant* result)
754 {
755     handleMouseWheel(arguments, result, false);
756 }
757
758 void EventSender::continuousMouseScrollBy(const CppArgumentList& arguments, CppVariant* result)
759 {
760     handleMouseWheel(arguments, result, true);
761 }
762
763 void EventSender::replaySavedEvents()
764 {
765     replayingSavedEvents = true;
766     while (!mouseEventQueue.isEmpty()) {
767         SavedEvent e = mouseEventQueue.takeFirst();
768
769         switch (e.type) {
770         case SavedEvent::MouseMove: {
771             WebMouseEvent event;
772             initMouseEvent(WebInputEvent::MouseMove, pressedButton, e.pos, &event);
773             doMouseMove(event);
774             break;
775         }
776         case SavedEvent::LeapForward:
777             doLeapForward(e.milliseconds);
778             break;
779         case SavedEvent::MouseUp: {
780             WebMouseEvent event;
781             initMouseEvent(WebInputEvent::MouseUp, e.buttonType, lastMousePos, &event);
782             doMouseUp(event);
783             break;
784         }
785         default:
786             ASSERT_NOT_REACHED();
787         }
788     }
789
790     replayingSavedEvents = false;
791 }
792
793 // Because actual context menu is implemented by the browser side, 
794 // this function does only what LayoutTests are expecting:
795 // - Many test checks the count of items. So returning non-zero value makes sense.
796 // - Some test compares the count before and after some action. So changing the count based on flags
797 //   also makes sense. This function is doing such for some flags.
798 // - Some test even checks actual string content. So providing it would be also helpful.
799 //
800 static Vector<WebString> makeMenuItemStringsFor(WebContextMenuData* contextMenu, TestDelegate* delegate)
801 {
802     // These constants are based on Safari's context menu because tests are made for it.
803     static const char* nonEditableMenuStrings[] = { "Back", "Reload Page", "Open in Dashbaord", "<separator>", "View Source", "Save Page As", "Print Page", "Inspect Element", 0 };
804     static const char* editableMenuStrings[] = { "Cut", "Copy", "<separator>", "Paste", "Spelling and Grammar", "Substitutions, Transformations", "Font", "Speech", "Paragraph Direction", "<separator>", 0 };
805
806     // This is possible because mouse events are cancelleable.
807     if (!contextMenu)
808         return Vector<WebString>();
809
810     Vector<WebString> strings;
811
812     if (contextMenu->isEditable) {
813         for (const char** item = editableMenuStrings; *item; ++item) 
814             strings.append(WebString::fromUTF8(*item));
815         Vector<WebString> suggestions;
816         delegate->fillSpellingSuggestionList(contextMenu->misspelledWord, &suggestions);
817         for (size_t i = 0; i < suggestions.size(); ++i) 
818             strings.append(suggestions[i]);
819     } else {
820         for (const char** item = nonEditableMenuStrings; *item; ++item) 
821             strings.append(WebString::fromUTF8(*item));
822     }
823
824     return strings;
825 }
826
827 void EventSender::contextClick(const CppArgumentList& arguments, CppVariant* result)
828 {
829     webview()->layout();
830
831     updateClickCountForButton(WebMouseEvent::ButtonRight);
832
833     // Clears last context menu data because we need to know if the context menu be requested 
834     // after following mouse events.
835     m_delegate->clearContextMenuData();
836
837     // Generate right mouse down and up.
838     WebMouseEvent event;
839     pressedButton = WebMouseEvent::ButtonRight;
840     initMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::ButtonRight, lastMousePos, &event);
841     webview()->handleInputEvent(event);
842
843     initMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::ButtonRight, lastMousePos, &event);
844     webview()->handleInputEvent(event);
845
846     pressedButton = WebMouseEvent::ButtonNone;
847
848     WebContextMenuData* lastContextMenu = m_delegate->lastContextMenuData();
849     result->set(WebBindings::makeStringArray(makeMenuItemStringsFor(lastContextMenu, m_delegate)));
850 }
851
852 class MouseDownTask: public MethodTask<EventSender> {
853 public:
854     MouseDownTask(EventSender* obj, const CppArgumentList& arg)
855         : MethodTask<EventSender>(obj), m_arguments(arg) { }
856     virtual void runIfValid() { m_object->mouseDown(m_arguments, 0); }
857
858 private:
859     CppArgumentList m_arguments;
860 };
861
862 class MouseUpTask: public MethodTask<EventSender> {
863 public:
864     MouseUpTask(EventSender* obj, const CppArgumentList& arg)
865         : MethodTask<EventSender>(obj), m_arguments(arg) { }
866     virtual void runIfValid() { m_object->mouseUp(m_arguments, 0); }
867
868 private:
869     CppArgumentList m_arguments;
870 };
871
872 void EventSender::scheduleAsynchronousClick(const CppArgumentList& arguments, CppVariant* result)
873 {
874     result->setNull();
875     postTask(new MouseDownTask(this, arguments));
876     postTask(new MouseUpTask(this, arguments));
877 }
878
879 class KeyDownTask : public MethodTask<EventSender> {
880 public:
881     KeyDownTask(EventSender* obj, const CppArgumentList& arg)
882         : MethodTask<EventSender>(obj), m_arguments(arg) { }
883     virtual void runIfValid() { m_object->keyDown(m_arguments, 0); }
884
885 private:
886     CppArgumentList m_arguments;
887 };
888
889 void EventSender::scheduleAsynchronousKeyDown(const CppArgumentList& arguments, CppVariant* result)
890 {
891     result->setNull();
892     postTask(new KeyDownTask(this, arguments));
893 }
894
895 void EventSender::beginDragWithFiles(const CppArgumentList& arguments, CppVariant* result)
896 {
897     currentDragData.initialize();
898     Vector<string> files = arguments[0].toStringVector();
899     Vector<WebString> absoluteFilenames;
900     for (size_t i = 0; i < files.size(); ++i) {
901         WebDragData::Item item;
902         item.storageType = WebDragData::Item::StorageTypeFilename;
903         item.filenameData = webkit_support::GetAbsoluteWebStringFromUTF8Path(files[i]);
904         currentDragData.addItem(item);
905         absoluteFilenames.append(item.filenameData);
906     }
907     currentDragData.setFilesystemId(webkit_support::RegisterIsolatedFileSystem(absoluteFilenames));
908     currentDragEffectsAllowed = WebKit::WebDragOperationCopy;
909
910     // Provide a drag source.
911     webview()->dragTargetDragEnter(currentDragData, lastMousePos, lastMousePos, currentDragEffectsAllowed, 0);
912
913     // dragMode saves events and then replays them later. We don't need/want that.
914     dragMode.set(false);
915
916     // Make the rest of eventSender think a drag is in progress.
917     pressedButton = WebMouseEvent::ButtonLeft;
918
919     result->setNull();
920 }
921
922 void EventSender::addTouchPoint(const CppArgumentList& arguments, CppVariant* result)
923 {
924     result->setNull();
925
926     WebTouchPoint touchPoint;
927     touchPoint.state = WebTouchPoint::StatePressed;
928     touchPoint.position = WebPoint(arguments[0].toInt32(), arguments[1].toInt32());
929     touchPoint.screenPosition = touchPoint.position;
930
931     int lowestId = 0;
932     for (size_t i = 0; i < touchPoints.size(); i++) {
933         if (touchPoints[i].id == lowestId)
934             lowestId++;
935     }
936     touchPoint.id = lowestId;
937     touchPoints.append(touchPoint);
938 }
939
940 void EventSender::clearTouchPoints(const CppArgumentList&, CppVariant* result)
941 {
942     result->setNull();
943     touchPoints.clear();
944 }
945
946 void EventSender::releaseTouchPoint(const CppArgumentList& arguments, CppVariant* result)
947 {
948     result->setNull();
949
950     const unsigned index = arguments[0].toInt32();
951     ASSERT(index < touchPoints.size());
952
953     WebTouchPoint* touchPoint = &touchPoints[index];
954     touchPoint->state = WebTouchPoint::StateReleased;
955 }
956
957 void EventSender::setTouchModifier(const CppArgumentList& arguments, CppVariant* result)
958 {
959     result->setNull();
960
961     int mask = 0;
962     const string keyName = arguments[0].toString();
963     if (keyName == "shift")
964         mask = WebInputEvent::ShiftKey;
965     else if (keyName == "alt")
966         mask = WebInputEvent::AltKey;
967     else if (keyName == "ctrl")
968         mask = WebInputEvent::ControlKey;
969     else if (keyName == "meta")
970         mask = WebInputEvent::MetaKey;
971
972     if (arguments[1].toBoolean())
973         touchModifiers |= mask;
974     else
975         touchModifiers &= ~mask;
976 }
977
978 void EventSender::updateTouchPoint(const CppArgumentList& arguments, CppVariant* result)
979 {
980     result->setNull();
981
982     const unsigned index = arguments[0].toInt32();
983     ASSERT(index < touchPoints.size());
984
985     WebPoint position(arguments[1].toInt32(), arguments[2].toInt32());
986     WebTouchPoint* touchPoint = &touchPoints[index];
987     touchPoint->state = WebTouchPoint::StateMoved;
988     touchPoint->position = position;
989     touchPoint->screenPosition = position;
990 }
991
992 void EventSender::cancelTouchPoint(const CppArgumentList& arguments, CppVariant* result)
993 {
994     result->setNull();
995
996     const unsigned index = arguments[0].toInt32();
997     ASSERT(index < touchPoints.size());
998
999     WebTouchPoint* touchPoint = &touchPoints[index];
1000     touchPoint->state = WebTouchPoint::StateCancelled;
1001 }
1002
1003 void EventSender::sendCurrentTouchEvent(const WebInputEvent::Type type)
1004 {
1005     ASSERT(static_cast<unsigned>(WebTouchEvent::touchesLengthCap) > touchPoints.size());
1006     webview()->layout();
1007
1008     WebTouchEvent touchEvent;
1009     touchEvent.type = type;
1010     touchEvent.modifiers = touchModifiers;
1011     touchEvent.timeStampSeconds = getCurrentEventTimeSec();
1012     touchEvent.touchesLength = touchPoints.size();
1013     for (unsigned i = 0; i < touchPoints.size(); ++i)
1014         touchEvent.touches[i] = touchPoints[i];
1015     webview()->handleInputEvent(touchEvent);
1016
1017     for (unsigned i = 0; i < touchPoints.size(); ++i) {
1018         WebTouchPoint* touchPoint = &touchPoints[i];
1019         if (touchPoint->state == WebTouchPoint::StateReleased) {
1020             touchPoints.remove(i);
1021             --i;
1022         } else
1023             touchPoint->state = WebTouchPoint::StateStationary;
1024     }
1025 }
1026
1027 void EventSender::handleMouseWheel(const CppArgumentList& arguments, CppVariant* result, bool continuous)
1028 {
1029     result->setNull();
1030
1031     if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
1032         return;
1033
1034     // Force a layout here just to make sure every position has been
1035     // determined before we send events (as well as all the other methods
1036     // that send an event do).
1037     webview()->layout();
1038
1039     int horizontal = arguments[0].toInt32();
1040     int vertical = arguments[1].toInt32();
1041     int paged = false;
1042     int hasPreciseScrollingDeltas = false;
1043
1044     if (arguments.size() > 2 && arguments[2].isBool())
1045         paged = arguments[2].toBoolean();
1046
1047     if (arguments.size() > 3 && arguments[3].isBool())
1048         hasPreciseScrollingDeltas = arguments[3].toBoolean();
1049
1050     WebMouseWheelEvent event;
1051     initMouseEvent(WebInputEvent::MouseWheel, pressedButton, lastMousePos, &event);
1052     event.wheelTicksX = static_cast<float>(horizontal);
1053     event.wheelTicksY = static_cast<float>(vertical);
1054     event.deltaX = event.wheelTicksX;
1055     event.deltaY = event.wheelTicksY;
1056     event.scrollByPage = paged;
1057     event.hasPreciseScrollingDeltas = hasPreciseScrollingDeltas;
1058
1059     if (continuous) {
1060         event.wheelTicksX /= scrollbarPixelsPerTick;
1061         event.wheelTicksY /= scrollbarPixelsPerTick;
1062     } else {
1063         event.deltaX *= scrollbarPixelsPerTick;
1064         event.deltaY *= scrollbarPixelsPerTick;
1065     }
1066     webview()->handleInputEvent(event);
1067 }
1068
1069 void EventSender::touchEnd(const CppArgumentList&, CppVariant* result)
1070 {
1071     result->setNull();
1072     sendCurrentTouchEvent(WebInputEvent::TouchEnd);
1073 }
1074
1075 void EventSender::touchMove(const CppArgumentList&, CppVariant* result)
1076 {
1077     result->setNull();
1078     sendCurrentTouchEvent(WebInputEvent::TouchMove);
1079 }
1080
1081 void EventSender::touchStart(const CppArgumentList&, CppVariant* result)
1082 {
1083     result->setNull();
1084     sendCurrentTouchEvent(WebInputEvent::TouchStart);
1085 }
1086
1087 void EventSender::touchCancel(const CppArgumentList&, CppVariant* result)
1088 {
1089     result->setNull();
1090     sendCurrentTouchEvent(WebInputEvent::TouchCancel);
1091 }
1092
1093 void EventSender::gestureScrollBegin(const CppArgumentList& arguments, CppVariant* result)
1094 {
1095     result->setNull();
1096     gestureEvent(WebInputEvent::GestureScrollBegin, arguments);
1097 }
1098
1099 void EventSender::gestureScrollEnd(const CppArgumentList& arguments, CppVariant* result)
1100 {
1101     result->setNull();
1102     gestureEvent(WebInputEvent::GestureScrollEnd, arguments);
1103 }
1104
1105 void EventSender::gestureScrollUpdate(const CppArgumentList& arguments, CppVariant* result)
1106 {
1107     result->setNull();
1108     gestureEvent(WebInputEvent::GestureScrollUpdate, arguments);
1109 }
1110
1111 void EventSender::gestureTap(const CppArgumentList& arguments, CppVariant* result)
1112 {
1113     result->setNull();
1114     gestureEvent(WebInputEvent::GestureTap, arguments);
1115 }
1116
1117 void EventSender::gestureTapDown(const CppArgumentList& arguments, CppVariant* result)
1118 {
1119     result->setNull();
1120     gestureEvent(WebInputEvent::GestureTapDown, arguments);
1121 }
1122
1123 void EventSender::gestureTapCancel(const CppArgumentList& arguments, CppVariant* result)
1124 {
1125     result->setNull();
1126     gestureEvent(WebInputEvent::GestureTapCancel, arguments);
1127 }
1128
1129 void EventSender::gestureLongPress(const CppArgumentList& arguments, CppVariant* result)
1130 {
1131     result->setNull();
1132     gestureEvent(WebInputEvent::GestureLongPress, arguments);
1133 }
1134
1135 void EventSender::gestureTwoFingerTap(const CppArgumentList& arguments, CppVariant* result)
1136 {
1137     result->setNull();
1138     gestureEvent(WebInputEvent::GestureTwoFingerTap, arguments);
1139 }
1140
1141 void EventSender::gestureScrollFirstPoint(const CppArgumentList& arguments, CppVariant* result)
1142 {
1143     result->setNull();
1144     if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
1145         return;
1146
1147     WebPoint point(arguments[0].toInt32(), arguments[1].toInt32());
1148     m_currentGestureLocation = point;
1149 }
1150
1151 void EventSender::gestureEvent(WebInputEvent::Type type, const CppArgumentList& arguments)
1152 {
1153     if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isNumber())
1154         return;
1155
1156     WebPoint point(arguments[0].toInt32(), arguments[1].toInt32());
1157
1158     WebGestureEvent event;
1159     event.type = type;
1160
1161     switch (type) {
1162     case WebInputEvent::GestureScrollUpdate:
1163         event.data.scrollUpdate.deltaX = static_cast<float>(arguments[0].toDouble());
1164         event.data.scrollUpdate.deltaY = static_cast<float>(arguments[1].toDouble());
1165         event.x = m_currentGestureLocation.x;
1166         event.y = m_currentGestureLocation.y;
1167         m_currentGestureLocation.x = m_currentGestureLocation.x + event.data.scrollUpdate.deltaX;
1168         m_currentGestureLocation.y = m_currentGestureLocation.y + event.data.scrollUpdate.deltaY;
1169         break;
1170
1171     case WebInputEvent::GestureScrollBegin:
1172         m_currentGestureLocation = WebPoint(point.x, point.y);
1173         event.x = m_currentGestureLocation.x;
1174         event.y = m_currentGestureLocation.y;
1175         break;
1176     case WebInputEvent::GestureScrollEnd:
1177         event.x = m_currentGestureLocation.x;
1178         event.y = m_currentGestureLocation.y;
1179         break;
1180     case WebInputEvent::GestureTap:
1181         if (arguments.size() >= 3)
1182             event.data.tap.tapCount = static_cast<float>(arguments[2].toDouble());
1183         else
1184           event.data.tap.tapCount = 1;
1185         event.x = point.x;
1186         event.y = point.y;
1187         break;
1188     case WebInputEvent::GestureTapDown:
1189         event.x = point.x;
1190         event.y = point.y;
1191         if (arguments.size() >= 4) {
1192             event.data.tapDown.width = static_cast<float>(arguments[2].toDouble());
1193             event.data.tapDown.height = static_cast<float>(arguments[3].toDouble());
1194         }
1195         break;
1196     case WebInputEvent::GestureTapCancel:
1197         event.x = point.x;
1198         event.y = point.y;
1199         break;
1200     case WebInputEvent::GestureLongPress:
1201         event.x = point.x;
1202         event.y = point.y;
1203         break;
1204     case WebInputEvent::GestureTwoFingerTap:
1205         event.x = point.x;
1206         event.y = point.y;
1207         break;
1208     default:
1209         ASSERT_NOT_REACHED();
1210     }
1211
1212     event.globalX = event.x;
1213     event.globalY = event.y;
1214     event.timeStampSeconds = getCurrentEventTimeSec();
1215     webview()->handleInputEvent(event);
1216 }
1217
1218 void EventSender::gestureFlingCancel(const CppArgumentList& arguments, CppVariant* result)
1219 {
1220     result->setNull();
1221     if (!arguments.size())
1222         return;
1223
1224     WebGestureEvent event;
1225     event.type = WebInputEvent::GestureFlingCancel;
1226     event.timeStampSeconds = getCurrentEventTimeSec();
1227     webview()->handleInputEvent(event);
1228 }
1229
1230 void EventSender::gestureFlingStart(const CppArgumentList& arguments, CppVariant* result)
1231 {
1232     result->setNull();
1233     if (arguments.size() < 4)
1234         return;
1235
1236     for (int i = 0; i < 4; i++)
1237         if (!arguments[i].isNumber())
1238             return;
1239
1240     WebGestureEvent event;
1241     event.type = WebInputEvent::GestureFlingStart;
1242
1243     event.x = static_cast<float>(arguments[0].toDouble());
1244     event.y = static_cast<float>(arguments[1].toDouble());
1245     event.globalX = event.x;
1246     event.globalY = event.y;
1247
1248     event.data.flingStart.velocityX = static_cast<float>(arguments[2].toDouble());
1249     event.data.flingStart.velocityY = static_cast<float>(arguments[3].toDouble());
1250     event.timeStampSeconds = getCurrentEventTimeSec();
1251     webview()->handleInputEvent(event);
1252 }
1253
1254 //
1255 // Unimplemented stubs
1256 //
1257
1258 void EventSender::enableDOMUIEventLogging(const CppArgumentList&, CppVariant* result)
1259 {
1260     result->setNull();
1261 }
1262
1263 void EventSender::fireKeyboardEventsToElement(const CppArgumentList&, CppVariant* result)
1264 {
1265     result->setNull();
1266 }
1267
1268 void EventSender::clearKillRing(const CppArgumentList&, CppVariant* result)
1269 {
1270     result->setNull();
1271 }