Fix EventSendingController so that we do event saving and replay like what We...

webkit/tools/test_shell/event_sending_controller.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains the definition for EventSendingController.
 //
 // Some notes about drag and drop handling:
 // Windows drag and drop goes through a system call to DoDragDrop.  At that
 // point, program control is given to Windows which then periodically makes
 // callbacks into the webview.  This won't work for layout tests, so instead,
@@ skipping 50 matching lines @@
 
 TestShell* EventSendingController::shell_ = NULL;
 gfx::Point EventSendingController::last_mouse_pos_;
 WebMouseEvent::Button EventSendingController::pressed_button_ =
     WebMouseEvent::ButtonNone;
 
 int EventSendingController::last_button_number_ = -1;
 
 namespace {
 
+struct SavedEvent {
+  enum SavedEventType {
+    Unspecified,
+    MouseUp,
+    MouseMove,
+    LeapForward
+  };
+
+  SavedEventType type;
+  WebMouseEvent::Button button_type;  // For MouseUp
+  gfx::Point pos;                     // For MouseMove.
+  int milliseconds;                   // For LeapForward.
+
+  SavedEvent()
+    : type(Unspecified),
+      button_type(WebMouseEvent::ButtonNone),
+      milliseconds(0) {
+  }
+};
+
 static WebDragData current_drag_data;
 static WebDragOperation current_drag_effect;
 static WebDragOperationsMask current_drag_effects_allowed;
 static bool replaying_saved_events = false;
-static std::queue<WebMouseEvent> mouse_event_queue;
+static std::queue<SavedEvent> mouse_event_queue;
 
 // Time and place of the last mouse up event.
 static double last_click_time_sec = 0;
 static gfx::Point last_click_pos;
 static int click_count = 0;
 
 // maximum distance (in space and time) for a mouse click
 // to register as a double or triple click
 static const double kMultiClickTimeSec = 1;
 static const int kMultiClickRadiusPixels = 5;
@@ skipping 120 matching lines @@
 #if defined(OS_WIN)
   wmKeyDown.Set(WM_KEYDOWN);
   wmKeyUp.Set(WM_KEYUP);
   wmChar.Set(WM_CHAR);
   wmDeadChar.Set(WM_DEADCHAR);
   wmSysKeyDown.Set(WM_SYSKEYDOWN);
   wmSysKeyUp.Set(WM_SYSKEYUP);
   wmSysChar.Set(WM_SYSCHAR);
   wmSysDeadChar.Set(WM_SYSDEADCHAR);
 #endif
+  last_mouse_pos_.SetPoint(0, 0);
   last_click_time_sec = 0;
+  last_click_pos.SetPoint(0, 0);
   click_count = 0;
   last_button_number_ = -1;
+  time_offset_ms = 0;
 }
 
 // static
 WebView* EventSendingController::webview() {
   return shell_->webView();
 }
 
 // static
 void EventSendingController::DoDragDrop(const WebKit::WebPoint &event_pos,
                                         const WebDragData& drag_data,
                                         WebDragOperationsMask mask) {
   WebMouseEvent event;
-  InitMouseEvent(WebInputEvent::MouseDown, pressed_button_, event_pos, &event);
+  InitMouseEvent(WebInputEvent::MouseDown, pressed_button_, last_mouse_pos_, &event);
   WebPoint client_point(event.x, event.y);
   WebPoint screen_point(event.globalX, event.globalY);
   current_drag_data = drag_data;
   current_drag_effects_allowed = mask;
   current_drag_effect = webview()->dragTargetDragEnter(
       drag_data, 0, client_point, screen_point, current_drag_effects_allowed);
 
   // Finish processing events.
   ReplaySavedEvents();
 }
@@ skipping 13 matching lines @@
     const CppArgumentList& args) {
   int button_code = 0;
 
   if (args.size() > 0 && args[0].isNumber()) {
     button_code = args[0].ToInt32();
   }
 
   return button_code;
 }
 
+void EventSendingController::UpdateClickCountForButton(int button_number) {

[dglazkov, 2009/10/14 01:32:00]

Can this take an enum instead?

+  if ((GetCurrentEventTimeSec() - last_click_time_sec < kMultiClickTimeSec) &&
+      (!outside_multiclick_radius(last_mouse_pos_, last_click_pos)) &&
+      (button_number == last_button_number_)) {
+    ++click_count;
+  } else {
+    click_count = 1;
+    last_button_number_ = button_number;
+  }
+}
+
 //
 // Implemented javascript methods.
 //
 
 void EventSendingController::mouseDown(
     const CppArgumentList& args, CppVariant* result) {
   if (result)  // Could be NULL if invoked asynchronously.
     result->SetNull();
 
   webview()->layout();
 
   int button_number = GetButtonNumberFromSingleArg(args);
   DCHECK(button_number != -1);
 
   WebMouseEvent::Button button_type = GetButtonTypeFromButtonNumber(
       button_number);
 
-  if ((GetCurrentEventTimeSec() - last_click_time_sec < kMultiClickTimeSec) &&
-      (!outside_multiclick_radius(last_mouse_pos_, last_click_pos)) &&
-      (button_number == last_button_number_)) {
-    ++click_count;
-  } else {
-    click_count = 1;
-  }
-
-  last_button_number_ = button_number;
+  UpdateClickCountForButton(button_number);
 
   WebMouseEvent event;
   pressed_button_ = button_type;
   InitMouseEvent(WebInputEvent::MouseDown, button_type,
                  last_mouse_pos_, &event);
   webview()->handleInputEvent(event);
 }
 
 void EventSendingController::mouseUp(
     const CppArgumentList& args, CppVariant* result) {
   if (result)  // Could be NULL if invoked asynchronously.
     result->SetNull();
 
   webview()->layout();
 
   int button_number = GetButtonNumberFromSingleArg(args);
   DCHECK(button_number != -1);
 
   WebMouseEvent::Button button_type = GetButtonTypeFromButtonNumber(
       button_number);
 
-  last_button_number_ = button_number;
-
-  WebMouseEvent event;
-  InitMouseEvent(WebInputEvent::MouseUp, button_type,
-                 last_mouse_pos_, &event);
   if (drag_mode() && !replaying_saved_events) {
-    mouse_event_queue.push(event);
+    SavedEvent saved_event;
+    saved_event.type = SavedEvent::MouseUp;
+    saved_event.button_type = button_type;
+    mouse_event_queue.push(saved_event);
     ReplaySavedEvents();
   } else {
+    WebMouseEvent event;
+    InitMouseEvent(WebInputEvent::MouseUp, button_type,
+                   last_mouse_pos_, &event);
     DoMouseUp(event);
   }
-
-  last_click_time_sec = event.timeStampSeconds;
-  last_click_pos = gfx::Point(event.x, event.y);
 }
 
 /* static */ void EventSendingController::DoMouseUp(const WebMouseEvent& e) {
   webview()->handleInputEvent(e);
+
   pressed_button_ = WebMouseEvent::ButtonNone;
+  last_click_time_sec = e.timeStampSeconds;
+  last_click_pos = last_mouse_pos_;
 
   // If we're in a drag operation, complete it.
   if (!current_drag_data.isNull()) {
     WebPoint client_point(e.x, e.y);
     WebPoint screen_point(e.globalX, e.globalY);
 
     webview()->dragSourceMovedTo(client_point, screen_point);
     current_drag_effect = webview()->dragTargetDragOver(
         client_point, screen_point, current_drag_effects_allowed);
     if (current_drag_effect) {
       webview()->dragTargetDrop(client_point, screen_point);
     } else {
       webview()->dragTargetDragLeave();
     }
     webview()->dragSourceEndedAt(
         client_point, screen_point, current_drag_effect);
+    webview()->dragSourceSystemDragEnded();
 
     current_drag_data.reset();
   }
 }
 
 void EventSendingController::mouseMoveTo(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 
   if (args.size() >= 2 && args[0].isNumber() && args[1].isNumber()) {
     webview()->layout();
 
-    WebMouseEvent event;
-    last_mouse_pos_.SetPoint(args[0].ToInt32(), args[1].ToInt32());
-    InitMouseEvent(WebInputEvent::MouseMove, pressed_button_,
-                   last_mouse_pos_, &event);
+    gfx::Point mouse_pos;
+    mouse_pos.SetPoint(args[0].ToInt32(), args[1].ToInt32());
 
-    if (drag_mode() && pressed_button_ != WebMouseEvent::ButtonNone &&
+    if (drag_mode() && pressed_button_ == WebMouseEvent::ButtonLeft &&
         !replaying_saved_events) {
-      mouse_event_queue.push(event);
+      SavedEvent saved_event;
+      saved_event.type = SavedEvent::MouseMove;
+      saved_event.pos = mouse_pos;
+      mouse_event_queue.push(saved_event);
     } else {
+      WebMouseEvent event;
+      InitMouseEvent(WebInputEvent::MouseMove, pressed_button_,
+                     mouse_pos, &event);
       DoMouseMove(event);
     }
   }
 }
 
 // static
 void EventSendingController::DoMouseMove(const WebMouseEvent& e) {
+  last_mouse_pos_.SetPoint(e.x, e.y);
+
   webview()->handleInputEvent(e);
 
   if (pressed_button_ != WebMouseEvent::ButtonNone &&
       !current_drag_data.isNull()) {
     WebPoint client_point(e.x, e.y);
     WebPoint screen_point(e.globalX, e.globalY);
 
     webview()->dragSourceMovedTo(client_point, screen_point);
     current_drag_effect = webview()->dragTargetDragOver(
         client_point, screen_point, current_drag_effects_allowed);
@@ skipping 136 matching lines @@
   // WebKit/WebKitTools/DumpRenderTree/Win/EventSender.cpp
   if ((key_code & 0xFF) >= 'A' && (key_code & 0xFF) <= 'Z')
     return true;
   return false;
 }
 
 void EventSendingController::leapForward(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 
-  // TODO(mpcomplete): DumpRenderTree defers this under certain conditions.
+  if (args.size() <1 || !args[0].isNumber())
+    return;
 
-  if (args.size() >=1 && args[0].isNumber()) {
-    AdvanceEventTime(args[0].ToInt32());
+  int milliseconds = args[0].ToInt32();
+  if (drag_mode() && pressed_button_ == WebMouseEvent::ButtonLeft &&
+      !replaying_saved_events) {
+    SavedEvent saved_event;
+    saved_event.type = SavedEvent::LeapForward;
+    saved_event.milliseconds = milliseconds;
+    mouse_event_queue.push(saved_event);
+  } else {
+    DoLeapForward(milliseconds);
   }
 }
 
+/* static */ void EventSendingController::DoLeapForward(int milliseconds) {

[dglazkov, 2009/10/14 01:32:00]

I think you should just do // static at the top of this line. Right?

+  AdvanceEventTime(milliseconds);
+}
+
 // Apple's port of WebKit zooms by a factor of 1.2 (see
 // WebKit/WebView/WebView.mm)
 void EventSendingController::textZoomIn(
     const CppArgumentList& args, CppVariant* result) {
   webview()->zoomIn(true);
   result->SetNull();
 }
 
 void EventSendingController::textZoomOut(
     const CppArgumentList& args, CppVariant* result) {
   webview()->zoomOut(true);
   result->SetNull();
 }
 
 void EventSendingController::zoomPageIn(
     const CppArgumentList& args, CppVariant* result) {
   webview()->zoomIn(false);
   result->SetNull();
 }
 
 void EventSendingController::zoomPageOut(
     const CppArgumentList& args, CppVariant* result) {
   webview()->zoomOut(false);
   result->SetNull();
 }
 
 void EventSendingController::ReplaySavedEvents() {
   replaying_saved_events = true;
   while (!mouse_event_queue.empty()) {
-    WebMouseEvent event = mouse_event_queue.front();
+    SavedEvent e = mouse_event_queue.front();
     mouse_event_queue.pop();
 
-    switch (event.type) {
-      case WebInputEvent::MouseUp:
+    switch (e.type) {
+      case SavedEvent::MouseMove: {
+        WebMouseEvent event;
+        InitMouseEvent(WebInputEvent::MouseMove, pressed_button_,
+                       e.pos, &event);
+        DoMouseMove(event);
+        break;
+      }
+      case SavedEvent::LeapForward:
+        DoLeapForward(e.milliseconds);
+        break;
+      case SavedEvent::MouseUp: {
+        WebMouseEvent event;
+        InitMouseEvent(WebInputEvent::MouseUp, e.button_type,
+                       last_mouse_pos_, &event);
         DoMouseUp(event);
         break;
-      case WebInputEvent::MouseMove:
-        DoMouseMove(event);
-        break;
+      }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events = false;
 }
 
 void EventSendingController::contextClick(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 
   webview()->layout();
 
-  if (GetCurrentEventTimeSec() - last_click_time_sec >= 1) {
-    click_count = 1;
-  } else {
-    ++click_count;
-  }
+  UpdateClickCountForButton(2 /*RightMouseButton*/);
 
   // Generate right mouse down and up.
 
   WebMouseEvent event;
   pressed_button_ = WebMouseEvent::ButtonRight;
   InitMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::ButtonRight,
                  last_mouse_pos_, &event);
   webview()->handleInputEvent(event);
 
   InitMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::ButtonRight,
@@ skipping 54 matching lines @@
 
 void EventSendingController::fireKeyboardEventsToElement(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 }
 
 void EventSendingController::clearKillRing(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 }