Peek at the event queue for wheel events for gtk

chrome/browser/renderer_host/render_widget_host_view_gtk.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
 
 // If this gets included after the gtk headers, then a bunch of compiler
 // errors happen because of a "#define Status int" in Xlib.h, which interacts
 // badly with URLRequestStatus::Status.
 #include "chrome/common/render_messages.h"
@@ skipping 30 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "views/widget/tooltip_window_gtk.h"
 #endif  // defined(OS_CHROMEOS)
 
 static const int kMaxWindowWidth = 4000;
 static const int kMaxWindowHeight = 4000;
 static const char* kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
 
 #if defined(OS_CHROMEOS)
-static const float kDefaultVertScrollDelta = 20.0;
+// TODO(davemoore) Under Chromeos we are increasing the rate that the trackpad
+// generates events to get better precisions. Eventually we will coordinate the
+// driver and this setting to ensure they match.
+static const float kDefaultScrollPixelsPerTick = 20;
+#else
+// See WebInputEventFactor.cpp for a reason for this being the default
+// scroll size for linux.
+static const float kDefaultScrollPixelsPerTick = 160.0f / 3.0f;
 #endif
 
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseWheelEvent;
 
 // This class is a simple convenience wrapper for Gtk functions. It has only
 // static methods.
 class RenderWidgetHostViewGtkWidget {
  public:
   static GtkWidget* CreateNewWidget(RenderWidgetHostViewGtk* host_view) {
@@ skipping 241 matching lines @@
   }
 
   static gboolean ClientEvent(GtkWidget* widget, GdkEventClient* event,
                               RenderWidgetHostViewGtk* host_view) {
     LOG(INFO) << "client event type: " << event->message_type
               << " data_format: " << event->data_format
               << " data: " << event->data.l;
     return true;
   }
 
-#if defined(OS_CHROMEOS)
   // Allow the vertical scroll delta to be overridden from the command line.
   // This will allow us to test more easily to discover the amount
   // (either hard coded or computed) that's best.
-  static float GetVertScrollDelta() {
-    static float vert_scroll_delta = -1;
-    if (vert_scroll_delta < 0) {
-      vert_scroll_delta = kDefaultVertScrollDelta;
+  static float GetScrollPixelsPerTick() {
+    static float scroll_pixels = -1;
+    if (scroll_pixels < 0) {
+      scroll_pixels = kDefaultScrollPixelsPerTick;
       CommandLine* command_line = CommandLine::ForCurrentProcess();
-      std::string vert_scroll_option =
-          command_line->GetSwitchValueASCII(switches::kVertScrollDelta);
-      if (!vert_scroll_option.empty()) {
+      std::string scroll_pixels_option =
+          command_line->GetSwitchValueASCII(switches::kScrollPixels);
+      if (!scroll_pixels_option.empty()) {
         double v;
-        if (StringToDouble(vert_scroll_option, &v))
-          vert_scroll_delta = static_cast<float>(v);
+        if (StringToDouble(scroll_pixels_option, &v))
+          scroll_pixels = static_cast<float>(v);
       }
-      DCHECK_GT(vert_scroll_delta, 0);
+      DCHECK_GT(scroll_pixels, 0);
     }
-    return vert_scroll_delta;
+    return scroll_pixels;
   }
-#endif
+
+  // Return the net up / down (or left / right) distance represented by events
+  // in the  events will be removed from the queue. We only look at the top of
+  // queue...any other type of event will cause us not to look farther.
+  // If there is a change to the set of modifier keys or scroll axis
+  // in the events we will stop looking as well.
+  static int GetPendingScrollDelta(bool vert, guint current_event_state) {
+    int num_clicks = 0;
+    GdkEvent* event;
+    bool event_coalesced = true;
+    while ((event = gdk_event_get()) && event_coalesced) {
+      event_coalesced = false;
+      if (event->type == GDK_SCROLL) {
+        GdkEventScroll scroll = event->scroll;
+        if (scroll.state & GDK_SHIFT_MASK) {
+          if (scroll.direction == GDK_SCROLL_UP)
+            scroll.direction = GDK_SCROLL_LEFT;
+          else if (scroll.direction == GDK_SCROLL_DOWN)
+            scroll.direction = GDK_SCROLL_RIGHT;
+        }
+        if (vert) {
+          if (scroll.direction == GDK_SCROLL_UP ||
+              scroll.direction == GDK_SCROLL_DOWN) {
+            if (scroll.state == current_event_state) {
+              num_clicks += (scroll.direction == GDK_SCROLL_UP ? 1 : -1);
+              gdk_event_free(event);
+              event_coalesced = true;
+            }
+          }
+        } else {
+          if (scroll.direction == GDK_SCROLL_RIGHT ||
+              scroll.direction == GDK_SCROLL_LEFT) {
+            if (scroll.state == current_event_state) {
+              num_clicks += (scroll.direction == GDK_SCROLL_RIGHT ? 1 : -1);
+              gdk_event_free(event);
+              event_coalesced = true;
+            }
+          }
+        }
+      }
+    }
+    // If we have an event left we put it back on the queue.
+    if (event) {
+      gdk_event_put(event);
+      gdk_event_free(event);
+    }
+    return num_clicks * GetScrollPixelsPerTick();
+  }
 
   static gboolean MouseScrollEvent(GtkWidget* widget, GdkEventScroll* event,
                                    RenderWidgetHostViewGtk* host_view) {
     // If the user is holding shift, translate it into a horizontal scroll. We
     // don't care what other modifiers the user may be holding (zooming is
     // handled at the TabContentsView level).
     if (event->state & GDK_SHIFT_MASK) {
       if (event->direction == GDK_SCROLL_UP)
         event->direction = GDK_SCROLL_LEFT;
       else if (event->direction == GDK_SCROLL_DOWN)
         event->direction = GDK_SCROLL_RIGHT;
     }
 
     WebMouseWheelEvent web_event = WebInputEventFactory::mouseWheelEvent(event);
-#if defined (OS_CHROMEOS)
-    // Under ChromeOS we know that the wheel is a touchpad. The driver for this
-    // can generate events very quickly. We configure it to generate more
-    // events and scroll by a smaller amount on each, to give us better
-    // precision. This is only configured for vertical scrolling, and
-    // doesn't apply if we are using the shift modifier to cause a horizontal
-    // scroll.
-    if (!(event->state & GDK_SHIFT_MASK)) {
+    // We  peek ahead at the top of the queue to look for additional pending
+    // scroll events.
+    if (event->direction == GDK_SCROLL_UP ||
+        event->direction == GDK_SCROLL_DOWN) {
       if (event->direction == GDK_SCROLL_UP)
-        web_event.deltaY = GetVertScrollDelta();
+        web_event.deltaY = GetScrollPixelsPerTick();
       else
-        web_event.deltaY = -GetVertScrollDelta();
+        web_event.deltaY = -GetScrollPixelsPerTick();
+      web_event.deltaY += GetPendingScrollDelta(true, event->state);
+    } else {
+      if (event->direction == GDK_SCROLL_RIGHT)
+        web_event.deltaX = GetScrollPixelsPerTick();
+      else
+        web_event.deltaX = -GetScrollPixelsPerTick();
+      web_event.deltaX += GetPendingScrollDelta(false, event->state);
     }
-#endif // OS_CHROMEOS
     host_view->GetRenderWidgetHost()->ForwardWheelEvent(web_event);
     return FALSE;
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RenderWidgetHostViewGtkWidget);
 };
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
@@ skipping 538 matching lines @@
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }