Implement EventSender.mouseWheelTo method....

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 38 matching lines @@
 // TODO(mpcomplete): do we need modifiers for mouse events?
 
 using base::Time;
 using base::TimeTicks;
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
 using WebKit::WebDragData;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
+using WebKit::WebMouseWheelEvent;
 using WebKit::WebPoint;
 using WebKit::WebString;
 using WebKit::WebView;
 
 TestShell* EventSendingController::shell_ = NULL;
 gfx::Point EventSendingController::last_mouse_pos_;
 WebMouseEvent::Button EventSendingController::pressed_button_ =
     WebMouseEvent::ButtonNone;
 
 WebMouseEvent::Button EventSendingController::last_button_type_ =
@@ skipping 30 matching lines @@
 // 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;
 
+// How much we should scroll per event - the value here is chosen to
+// match the WebKit impl and layout test results.
+static const float kScrollbarPixelsPerTick = 40.0f;
+
 inline bool outside_multiclick_radius(const gfx::Point &a, const gfx::Point &b) {
   return ((a.x() - b.x()) * (a.x() - b.x()) + (a.y() - b.y()) * (a.y() - b.y())) >
     kMultiClickRadiusPixels * kMultiClickRadiusPixels;
 }
 
 // Used to offset the time the event hander things an event happened.  This is
 // done so tests can run without a delay, but bypass checks that are time
 // dependent (e.g., dragging has a timeout vs selection).
 static uint32 time_offset_ms = 0;
 
@@ skipping 57 matching lines @@
     shell_ = shell;
 
   // Initialize the map that associates methods of this class with the names
   // they will use when called by JavaScript.  The actual binding of those
   // names to their methods will be done by calling BindToJavaScript() (defined
   // by CppBoundClass, the parent to EventSendingController).
   BindMethod("mouseDown", &EventSendingController::mouseDown);
   BindMethod("mouseUp", &EventSendingController::mouseUp);
   BindMethod("contextClick", &EventSendingController::contextClick);
   BindMethod("mouseMoveTo", &EventSendingController::mouseMoveTo);
+  BindMethod("mouseWheelTo", &EventSendingController::mouseWheelTo);
   BindMethod("leapForward", &EventSendingController::leapForward);
   BindMethod("keyDown", &EventSendingController::keyDown);
   BindMethod("dispatchMessage", &EventSendingController::dispatchMessage);
   BindMethod("enableDOMUIEventLogging",
              &EventSendingController::enableDOMUIEventLogging);
   BindMethod("fireKeyboardEventsToElement",
              &EventSendingController::fireKeyboardEventsToElement);
   BindMethod("clearKillRing", &EventSendingController::clearKillRing);
   BindMethod("textZoomIn", &EventSendingController::textZoomIn);
   BindMethod("textZoomOut", &EventSendingController::textZoomOut);
@@ skipping 200 matching lines @@
       mouse_event_queue.push(saved_event);
     } else {
       WebMouseEvent event;
       InitMouseEvent(WebInputEvent::MouseMove, pressed_button_,
                      mouse_pos, &event);
       DoMouseMove(event);
     }
   }
 }
 
+void EventSendingController::mouseWheelTo(
+    const CppArgumentList& args, CppVariant* result) {
+  result->SetNull();
+
+  if (args.size() >= 2 && args[0].isNumber() && args[1].isNumber()) {
+    // Force a layout here just to make sure every position has been
+    // determined before we send events (as well as all the other methods
+    // that send an event do). The layout test calling this
+    // (scrollbars/overflow-scrollbar-horizontal-wheel-scroll.html, only one
+    // for now) does not rely on this though.
+    webview()->layout();
+
+    int horizontal = args[0].ToInt32();
+    int vertical = args[1].ToInt32();
+
+    WebMouseWheelEvent event;
+    InitMouseEvent(WebInputEvent::MouseWheel, pressed_button_,
+                   last_mouse_pos_, &event);
+    event.wheelTicksX = static_cast<float>(horizontal);
+    event.wheelTicksY = static_cast<float>(vertical);
+    event.deltaX = -horizontal * kScrollbarPixelsPerTick;
+    event.deltaY = -vertical * kScrollbarPixelsPerTick;
+    webview()->handleInputEvent(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);
@@ skipping 302 matching lines @@
 
 void EventSendingController::fireKeyboardEventsToElement(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 }
 
 void EventSendingController::clearKillRing(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 }