Peek at the event queue for wheel events for gtk

chrome/browser/renderer_host/render_widget_host.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.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/histogram.h"
 #include "base/keyboard_codes.h"
@@ skipping 70 matching lines @@
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_get_backing_store_(false),
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
-      suppress_next_char_events_(false),
-      spin_runloop_before_sending_wheel_event_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)) {
+      suppress_next_char_events_(false) {
   if (routing_id_ == MSG_ROUTING_NONE)
     routing_id_ = process_->GetNextRoutingID();
 
   process_->Attach(this, routing_id_);
   // Because the widget initializes as is_hidden_ == false,
   // tell the process host that we're alive.
   process_->WidgetRestored();
 }
 
 RenderWidgetHost::~RenderWidgetHost() {
@@ skipping 312 matching lines @@
   }
 
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
 }
 
 void RenderWidgetHost::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   if (ignore_input_events_ || process_->ignore_input_events())
     return;
 
-  spin_runloop_before_sending_wheel_event_ = true;
-
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
   // event, as for mouse moves) results in very slow scrolling on the Mac (on
   // which many, very small wheel events are sent).
   if (mouse_wheel_pending_) {
     if (coalesced_mouse_wheel_events_.empty() ||
         coalesced_mouse_wheel_events_.back().modifiers
             != wheel_event.modifiers ||
         coalesced_mouse_wheel_events_.back().scrollByPage
             != wheel_event.scrollByPage) {
       coalesced_mouse_wheel_events_.push_back(wheel_event);
     } else {
       WebMouseWheelEvent* last_wheel_event =
           &coalesced_mouse_wheel_events_.back();
       last_wheel_event->deltaX += wheel_event.deltaX;
       last_wheel_event->deltaY += wheel_event.deltaY;
       DCHECK_GE(wheel_event.timeStampSeconds,
                 last_wheel_event->timeStampSeconds);
       last_wheel_event->timeStampSeconds = wheel_event.timeStampSeconds;
     }
     return;
   }
   mouse_wheel_pending_ = true;
 
   HISTOGRAM_COUNTS_100("MPArch.RWH_WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
-  last_wheel_message_time_ = TimeTicks::Now();
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
 }
 
 void RenderWidgetHost::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   if (ignore_input_events_ || process_->ignore_input_events())
     return;
 
   if (key_event.type == WebKeyboardEvent::Char &&
       (key_event.windowsKeyCode == base::VKEY_RETURN ||
@@ skipping 92 matching lines @@
 void RenderWidgetHost::RendererExited() {
   // Clearing this flag causes us to re-create the renderer when recovering
   // from a crashed renderer.
   renderer_initialized_ = false;
 
   // Must reset these to ensure that mouse move/wheel events work with a new
   // renderer.
   mouse_move_pending_ = false;
   next_mouse_move_.reset();
   mouse_wheel_pending_ = false;
-  spin_runloop_before_sending_wheel_event_ = false;
   coalesced_mouse_wheel_events_.clear();
 
   // Must reset these to ensure that keyboard events work with a new renderer.
   key_queue_.clear();
   suppress_next_char_events_ = false;
 
   // Reset some fields in preparation for recovering from a crash.
   resize_ack_pending_ = false;
   repaint_ack_pending_ = false;
 
@@ skipping 283 matching lines @@
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     bool processed = false;
     if (!message.ReadBool(&iter, &processed))
       process()->ReceivedBadMessage(message.type());
 
     ProcessKeyboardEventAck(type, processed);
   }
 }
 
 void RenderWidgetHost::ProcessWheelAck() {
-  static const base::TimeDelta kMaxTimeBetweenWheelMessages =
-      base::TimeDelta::FromMilliseconds(kMaxTimeBetweenWheelMessagesMs);
-
-  // Allow additional wheel events pending in the message queue to be coalesced.
-  if (spin_runloop_before_sending_wheel_event_) {
-    base::TimeDelta time_since_last_wheel_message_ =
-        TimeTicks::Now() - last_wheel_message_time_;
-    if (time_since_last_wheel_message_ < kMaxTimeBetweenWheelMessages) {
-      spin_runloop_before_sending_wheel_event_ = false;
-      MessageLoop::current()->PostTask(FROM_HERE,
-          method_runner_.NewRunnableMethod(&RenderWidgetHost::ProcessWheelAck));
-      return;
-    }
-  }
-
   mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     WebMouseWheelEvent next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     ForwardWheelEvent(next_wheel_event);
   }
 }
@@ skipping 278 matching lines @@
     // of this key event.
     if (!processed && !is_hidden_ && !front_item.skip_in_browser) {
       UnhandledKeyboardEvent(front_item);
 
       // WARNING: This RenderWidgetHost can be deallocated at this point
       // (i.e.  in the case of Ctrl+W, where the call to
       // UnhandledKeyboardEvent destroys this RenderWidgetHost).
     }
   }
 }