Refactoring: Extract gesture event filtering into helper class.

In the course of writing
http://src.chromium.org/viewvc/chrome?view=rev&revision=150463
I noticed that there was getting to be quite a bit of gesture
event related code in RenderWidgetHostImpl. This change gathers
this code together in an external helper class so that some
restructuring needed prior to completing 137555 is easier. This
CL should not change any functionality -- only moves code.

BUG=137555
TBR=jam@chromium.org


Review URL: https://chromiumcodereview.appspot.com/10823262

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151063 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/renderer_host/gesture_event_filter.cc

+// Copyright (c) 2012 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 "content/browser/renderer_host/gesture_event_filter.h"
+
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/tap_suppression_controller.h"
+
+using WebKit::WebGestureEvent;
+using WebKit::WebInputEvent;
+
+namespace content {
+namespace {
+// Returns |true| if two gesture events should be coalesced.
+bool ShouldCoalesceGestureEvents(const WebKit::WebGestureEvent& last_event,
+                                 const WebKit::WebGestureEvent& new_event) {
+  return new_event.type == WebInputEvent::GestureScrollUpdate &&
+      last_event.type == new_event.type &&
+      last_event.modifiers == new_event.modifiers;
+}
+} // namespace
+
+GestureEventFilter::GestureEventFilter(RenderWidgetHostImpl* rwhv)
+     : render_widget_host_(rwhv),
+       fling_in_progress_(false),
+       gesture_event_pending_(false),
+       tap_suppression_controller_(new TapSuppressionController(rwhv)) {
+}
+
+GestureEventFilter::~GestureEventFilter() { }
+
+bool GestureEventFilter::ShouldDiscardFlingCancelEvent(
+    const WebKit::WebGestureEvent& gesture_event) {
+  DCHECK(gesture_event.type == WebInputEvent::GestureFlingCancel);
+  if (coalesced_gesture_events_.empty() && fling_in_progress_)
+    return false;
+  GestureEventQueue::reverse_iterator it =
+      coalesced_gesture_events_.rbegin();
+  while (it != coalesced_gesture_events_.rend()) {
+    if (it->type == WebInputEvent::GestureFlingStart)
+      return false;
+    if (it->type == WebInputEvent::GestureFlingCancel)
+      return true;
+    it++;
+  }
+  return true;
+}
+
+bool GestureEventFilter::ShouldForward(const WebGestureEvent& gesture_event) {
+  if (gesture_event.type == WebInputEvent::GestureFlingCancel) {
+    if (ShouldDiscardFlingCancelEvent(gesture_event))
+      return false;
+    fling_in_progress_ = false;
+  }
+
+  if (gesture_event_pending_) {
+    if (coalesced_gesture_events_.empty() ||
+        !ShouldCoalesceGestureEvents(coalesced_gesture_events_.back(),
+                                     gesture_event)) {
+     coalesced_gesture_events_.push_back(gesture_event);
+    } else {
+      WebGestureEvent* last_gesture_event =
+          &coalesced_gesture_events_.back();
+      last_gesture_event->deltaX += gesture_event.deltaX;
+      last_gesture_event->deltaY += gesture_event.deltaY;
+      DCHECK_GE(gesture_event.timeStampSeconds,
+                last_gesture_event->timeStampSeconds);
+      last_gesture_event->timeStampSeconds = gesture_event.timeStampSeconds;
+    }
+    return false;
+  }
+  gesture_event_pending_ = true;
+
+  if (gesture_event.type == WebInputEvent::GestureFlingCancel) {
+    tap_suppression_controller_->GestureFlingCancel(
+        gesture_event.timeStampSeconds);
+  } else if (gesture_event.type == WebInputEvent::GestureFlingStart) {
+    fling_in_progress_ = true;
+  }
+
+  return true;
+}
+
+void GestureEventFilter::Reset() {
+  fling_in_progress_ = false;
+  coalesced_gesture_events_.clear();
+  gesture_event_pending_ = false;
+}
+
+void GestureEventFilter::ProcessGestureAck(bool processed, int type) {
+  if (type == WebInputEvent::GestureFlingCancel)
+    tap_suppression_controller_->GestureFlingCancelAck(processed);
+
+  gesture_event_pending_ = false;
+
+  // Now send the next (coalesced) gesture event.
+  if (!coalesced_gesture_events_.empty()) {
+    WebGestureEvent next_gesture_event =
+        coalesced_gesture_events_.front();
+    coalesced_gesture_events_.pop_front();
+    render_widget_host_->ForwardGestureEvent(next_gesture_event);
+  }
+}
+
+TapSuppressionController*  GestureEventFilter::GetTapSuppressionController() {
+  return tap_suppression_controller_.get();
+}
+
+void GestureEventFilter::FlingHasBeenHalted() {
+  fling_in_progress_ = false;
+}
+
+} // namespace content

content/browser/renderer_host/gesture_event_filter.h

+// Copyright (c) 2012 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_GESTURE_EVENT_FILTER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_GESTURE_EVENT_FILTER_H_
+
+#include <deque>
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+
+class MockRenderWidgetHost;
+
+namespace content {
+
+class RenderWidgetHostImpl;
+class TapSuppressionController;
+
+// Manages a queue of in-progress |WebGestureEvent| instances filtering,
+// coalescing or discarding them as required to maximize the chance that
+// the event stream can be handled entirely by the compositor thread.
+class GestureEventFilter {
+ public:
+  explicit GestureEventFilter(RenderWidgetHostImpl*);
+  ~GestureEventFilter();
+
+  // Returns |true| if the caller should immediately forward the provided
+  // |WebGestureEvent| argument to the renderer.
+  bool ShouldForward(const WebKit::WebGestureEvent&);
+
+  // Indicate that calling RenderWidgetHostImpl has received an acknowledgement
+  // from the renderer with state |processed| and event |type|. May send events
+  // if the queue is not empty.
+  void ProcessGestureAck(bool processed, int type);
+
+  // Reset the state of the filter as would be needed when the Renderer exits.
+  void Reset();
+
+  // Set the state of the |fling_in_progress_| field to indicate that a fling is
+  // definitely not in progress.
+  void FlingHasBeenHalted();
+
+  // Return the |TapSuppressionController| instance.
+  TapSuppressionController* GetTapSuppressionController();
+
+ private:
+  friend class ::MockRenderWidgetHost;
+
+  // Returns |true| if the given GestureFlingCancel should be discarded
+  // as unnecessary.
+  bool ShouldDiscardFlingCancelEvent(
+    const WebKit::WebGestureEvent& gesture_event);
+
+  // Only a RenderWidgetHostViewImpl can own an instance.
+  RenderWidgetHostImpl* render_widget_host_;
+
+  // True if a GestureFlingStart is in progress on the renderer.
+  bool fling_in_progress_;
+
+  // (Similar to |mouse_wheel_pending_|.). True if gesture event was sent and
+  // we are waiting for a corresponding ack.
+  bool gesture_event_pending_;
+
+  // An object tracking the state of touchpad action on the delivery of mouse
+  // events to the renderer to filter mouse actiosn immediately after a touchpad
+  // fling canceling tap.
+  scoped_ptr<TapSuppressionController> tap_suppression_controller_;
+
+  typedef std::deque<WebKit::WebGestureEvent> GestureEventQueue;
+
+  // (Similar to |coalesced_mouse_wheel_events_|.) GestureScrollUpdate events
+  // are coalesced by merging deltas in a similar fashion as wheel events.
+  GestureEventQueue coalesced_gesture_events_;
+
+  DISALLOW_COPY_AND_ASSIGN(GestureEventFilter);
+};
+
+} // namespace content
+
+#endif // CONTENT_BROWSER_RENDERER_HOST_GESTURE_EVENT_FILTER_H_

content/browser/renderer_host/render_widget_host_impl.cc

@@ -22,6 +22,7 @@
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
+#include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
@@ -94,14 +95,6 @@ bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
          last_event.momentumPhase == new_event.momentumPhase;
 }
 
-// Returns |true| if two gesture events should be coalesced.
-bool ShouldCoalesceGestureEvents(const WebKit::WebGestureEvent& last_event,
-                                 const WebKit::WebGestureEvent& new_event) {
-  return new_event.type == WebInputEvent::GestureScrollUpdate &&
-      last_event.type == new_event.type &&
-      last_event.modifiers == new_event.modifiers;
-}
-
 }  // namespace
 
 
@@ -137,7 +130,6 @@ RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
       should_auto_resize_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
-      gesture_event_pending_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_flight_event_count_(0),
@@ -153,8 +145,7 @@ RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
-      tap_suppression_controller_(new TapSuppressionController(this)),
-      fling_in_progress_(false) {
+      gesture_event_filter_(new GestureEventFilter(this)) {
   CHECK(delegate_);
   if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
@@ -496,7 +487,7 @@ void RenderWidgetHostImpl::ViewDestroyed() {
 
 void RenderWidgetHostImpl::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
-  fling_in_progress_ = false;
+  gesture_event_filter_->FlingHasBeenHalted();
   if (!view_)
     return;
   view_->SetIsLoading(is_loading);
@@ -872,11 +863,13 @@ void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
     }
     mouse_move_pending_ = true;
   } else if (mouse_event.type == WebInputEvent::MouseDown) {
-    if (tap_suppression_controller_->ShouldDeferMouseDown(mouse_event))
+    if (gesture_event_filter_->GetTapSuppressionController()->
+        ShouldDeferMouseDown(mouse_event))
       return;
     OnUserGesture();
   } else if (mouse_event.type == WebInputEvent::MouseUp) {
-    if (tap_suppression_controller_->ShouldSuppressMouseUp())
+    if (gesture_event_filter_->GetTapSuppressionController()->
+        ShouldSuppressMouseUp())
       return;
   }
 
@@ -926,39 +919,9 @@ void RenderWidgetHostImpl::ForwardWheelEvent(
 void RenderWidgetHostImpl::ForwardGestureEvent(
     const WebKit::WebGestureEvent& gesture_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardGestureEvent");
-  if (ignore_input_events_ || process_->IgnoreInputEvents())
-    return;
-
-  if (gesture_event.type == WebInputEvent::GestureFlingCancel) {
-    if (ShouldDiscardFlingCancelEvent(gesture_event))
-      return;
-    fling_in_progress_ = false;
-  }
-
-  if (gesture_event_pending_) {
-    if (coalesced_gesture_events_.empty() ||
-       !ShouldCoalesceGestureEvents(coalesced_gesture_events_.back(),
-                                    gesture_event)) {
-     coalesced_gesture_events_.push_back(gesture_event);
-    } else {
-      WebGestureEvent* last_gesture_event =
-          &coalesced_gesture_events_.back();
-      last_gesture_event->deltaX += gesture_event.deltaX;
-      last_gesture_event->deltaY += gesture_event.deltaY;
-      DCHECK_GE(gesture_event.timeStampSeconds,
-                last_gesture_event->timeStampSeconds);
-      last_gesture_event->timeStampSeconds = gesture_event.timeStampSeconds;
-    }
+  if (ignore_input_events_ || process_->IgnoreInputEvents() ||
+      !gesture_event_filter_->ShouldForward(gesture_event))
     return;
-  }
-  gesture_event_pending_ = true;
-
-  if (gesture_event.type == WebInputEvent::GestureFlingCancel) {
-    tap_suppression_controller_->GestureFlingCancel(
-        gesture_event.timeStampSeconds);
-  } else if (gesture_event.type == WebInputEvent::GestureFlingStart) {
-    fling_in_progress_ = true;
-  }
 
   ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
 }
@@ -1022,7 +985,7 @@ void RenderWidgetHostImpl::ForwardKeyboardEvent(
     key_queue_.push_back(key_event);
     HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
-    fling_in_progress_ = false; // Key events always stop flings.
+    gesture_event_filter_->FlingHasBeenHalted();
 
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
@@ -1121,8 +1084,7 @@ void RenderWidgetHostImpl::RendererExited(base::TerminationStatus status,
   coalesced_mouse_wheel_events_.clear();
 
   // Must reset these to ensure that gesture events work with a new renderer.
-  coalesced_gesture_events_.clear();
-  gesture_event_pending_ = false;
+  gesture_event_filter_->Reset();
 
   // Must reset these to ensure that keyboard events work with a new renderer.
   key_queue_.clear();
@@ -1624,23 +1586,6 @@ void RenderWidgetHostImpl::TickActiveSmoothScrollGesture() {
   }
 }
 
-bool RenderWidgetHostImpl::ShouldDiscardFlingCancelEvent(
-    const WebKit::WebGestureEvent& gesture_event) {
-  DCHECK(gesture_event.type == WebInputEvent::GestureFlingCancel);
-  if (coalesced_gesture_events_.empty() && fling_in_progress_)
-    return false;
-  GestureEventQueue::reverse_iterator it =
-      coalesced_gesture_events_.rbegin();
-  while (it != coalesced_gesture_events_.rend()) {
-    if (it->type == WebInputEvent::GestureFlingStart)
-      return false;
-    if (it->type == WebInputEvent::GestureFlingCancel)
-      return true;
-    it++;
-  }
-  return true;
-}
-
 void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
   mouse_wheel_pending_ = false;
 
@@ -1657,18 +1602,7 @@ void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
 }
 
 void RenderWidgetHostImpl::ProcessGestureAck(bool processed, int type) {
-  if (type == WebInputEvent::GestureFlingCancel)
-    tap_suppression_controller_->GestureFlingCancelAck(processed);
-
-  gesture_event_pending_ = false;
-
-  // Now send the next (coalesced) gesture event.
-  if (!coalesced_gesture_events_.empty()) {
-    WebGestureEvent next_gesture_event =
-        coalesced_gesture_events_.front();
-    coalesced_gesture_events_.pop_front();
-    ForwardGestureEvent(next_gesture_event);
-  }
+  gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
 void RenderWidgetHostImpl::ProcessTouchAck(

content/browser/renderer_host/render_widget_host_impl.h

@@ -46,10 +46,10 @@ struct WebScreenInfo;
 
 namespace content {
 class BackingStore;
+class GestureEventFilter;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostViewPort;
 class SmoothScrollGesture;
-class TapSuppressionController;
 
 // This implements the RenderWidgetHost interface that is exposed to
 // embedders of content, and adds things only visible to content.
@@ -602,11 +602,6 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   // initiated by OnMsgBeginSmoothScroll.
   void TickActiveSmoothScrollGesture();
 
-  // Returns |true| if the given GestureFlingCancel should be discarded
-  // as unnecessary.
-  bool ShouldDiscardFlingCancelEvent(
-      const WebKit::WebGestureEvent& gesture_event);
-
   // Our delegate, which wants to know mainly about keyboard events.
   RenderWidgetHostDelegate* delegate_;
 
@@ -686,16 +681,6 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   // would be queued) results in very slow scrolling.
   WheelEventQueue coalesced_mouse_wheel_events_;
 
-  // (Similar to |mouse_wheel_pending_|.). True if gesture event was sent and
-  // we are waiting for a corresponding ack.
-  bool gesture_event_pending_;
-
-  typedef std::deque<WebKit::WebGestureEvent> GestureEventQueue;
-
-  // (Similar to |coalesced_mouse_wheel_events_|.) GestureScrollUpdate events
-  // are coalesced by merging deltas in a similar fashion as wheel events.
-  GestureEventQueue coalesced_gesture_events_;
-
   // The time when an input event was sent to the RenderWidget.
   base::TimeTicks input_event_start_time_;
 
@@ -785,12 +770,10 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
 
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
-  scoped_ptr<TapSuppressionController> tap_suppression_controller_;
-
-  bool fling_in_progress_;
-
   scoped_ptr<SmoothScrollGesture> active_smooth_scroll_gesture_;
 
+  scoped_ptr<GestureEventFilter> gesture_event_filter_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 

content/browser/renderer_host/render_widget_host_unittest.cc

@@ -9,6 +9,7 @@
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
+#include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
@@ -32,6 +33,7 @@ using base::TimeDelta;
 using content::BackingStore;
 using content::BrowserThread;
 using content::BrowserThreadImpl;
+using content::GestureEventFilter;
 using content::MockRenderProcessHost;
 using content::NativeWebKeyboardEvent;
 using content::RenderWidgetHost;
@@ -223,8 +225,7 @@ class MockRenderWidgetHost : public RenderWidgetHostImpl {
   using RenderWidgetHostImpl::in_flight_size_;
   using RenderWidgetHostImpl::is_hidden_;
   using RenderWidgetHostImpl::resize_ack_pending_;
-  using RenderWidgetHostImpl::coalesced_gesture_events_;
-  using RenderWidgetHostImpl::fling_in_progress_;
+  using RenderWidgetHostImpl::gesture_event_filter_;
 
   bool unresponsive_timer_fired() const {
     return unresponsive_timer_fired_;
@@ -234,6 +235,18 @@ class MockRenderWidgetHost : public RenderWidgetHostImpl {
     hung_renderer_delay_ms_ = delay_ms;
   }
 
+  WebGestureEvent GestureEventLastQueueEvent() {
+    return gesture_event_filter_->coalesced_gesture_events_.back();
+  }
+
+  unsigned GestureEventLastQueueEventSize() {
+    return gesture_event_filter_->coalesced_gesture_events_.size();
+  }
+
+  bool FlingInProgress() {
+    return gesture_event_filter_->fling_in_progress_;
+  }
+
  protected:
   virtual void NotifyRendererUnresponsive() OVERRIDE {
     unresponsive_timer_fired_ = true;
@@ -795,14 +808,14 @@ TEST_F(RenderWidgetHostTest, CoalescesGesturesEvents) {
   SimulateGestureEvent(8, -5, 0, WebInputEvent::GestureScrollUpdate);
 
   // Make sure that the queue contains what we think it should.
-  WebGestureEvent merged_event = host_->coalesced_gesture_events_.back();
+  WebGestureEvent merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 
   // Coalesced.
   SimulateGestureEvent(8, -6, 0, WebInputEvent::GestureScrollUpdate);
 
   // Check that coalescing updated the correct values.
-  merged_event = host_->coalesced_gesture_events_.back();
+  merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(0, merged_event.modifiers);
   EXPECT_EQ(16, merged_event.deltaX);
@@ -812,7 +825,7 @@ TEST_F(RenderWidgetHostTest, CoalescesGesturesEvents) {
   SimulateGestureEvent(8, -7, 1, WebInputEvent::GestureScrollUpdate);
 
   // Check that we didn't wrongly coalesce.
-  merged_event = host_->coalesced_gesture_events_.back();
+  merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(1, merged_event.modifiers);
 
@@ -860,80 +873,80 @@ TEST_F(RenderWidgetHostTest, GestureFlingCancelsFiltered) {
   // GFC without previous GFS is dropped.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(0U, process_->sink().message_count());
-  EXPECT_EQ(0U, host_->coalesced_gesture_events_.size());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFC after previous GFS is dispatched and acked.
   process_->sink().ClearMessages();
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
-  EXPECT_TRUE(host_->fling_in_progress_);
+  EXPECT_TRUE(host_->FlingInProgress());
   SendInputEventACK(WebInputEvent::GestureFlingStart, true);
   MessageLoop::current()->RunAllPending();
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
-  EXPECT_FALSE(host_->fling_in_progress_);
+  EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(2U, process_->sink().message_count());
   SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
   MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0U, host_->coalesced_gesture_events_.size());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFC before previous GFS is acked.
   process_->sink().ClearMessages();
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
-  EXPECT_TRUE(host_->fling_in_progress_);
+  EXPECT_TRUE(host_->FlingInProgress());
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
-  EXPECT_FALSE(host_->fling_in_progress_);
+  EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_FALSE(host_->coalesced_gesture_events_.empty());
+  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
 
   // Advance state realistically.
   SendInputEventACK(WebInputEvent::GestureFlingStart, true);
   MessageLoop::current()->RunAllPending();
   SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
   MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0U, host_->coalesced_gesture_events_.size());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFS is added to the queue if another event is pending
   process_->sink().ClearMessages();
   SimulateGestureEvent(8, -7, 0, WebInputEvent::GestureScrollUpdate);
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
   EXPECT_EQ(1U, process_->sink().message_count());
-  WebGestureEvent merged_event = host_->coalesced_gesture_events_.back();
+  WebGestureEvent merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
-  EXPECT_FALSE(host_->fling_in_progress_);
-  EXPECT_EQ(1U, host_->coalesced_gesture_events_.size());
+  EXPECT_FALSE(host_->FlingInProgress());
+  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
 
   // GFS in queue means that a GFC is added to the queue
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
-  merged_event = host_->coalesced_gesture_events_.back();
+  merged_event =host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
-  EXPECT_FALSE(host_->fling_in_progress_);
-  EXPECT_EQ(2U, host_->coalesced_gesture_events_.size());
+  EXPECT_FALSE(host_->FlingInProgress());
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
 
 
   // Adding a second GFC is dropped.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
-  EXPECT_FALSE(host_->fling_in_progress_);
-  EXPECT_EQ(2U, host_->coalesced_gesture_events_.size());
+  EXPECT_FALSE(host_->FlingInProgress());
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
 
   // Adding another GFS will add it to the queue.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
-  merged_event = host_->coalesced_gesture_events_.back();
+  merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
-  EXPECT_FALSE(host_->fling_in_progress_);
-  EXPECT_EQ(3U, host_->coalesced_gesture_events_.size());
+  EXPECT_FALSE(host_->FlingInProgress());
+  EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
 
   // GFS in queue means that a GFC is added to the queue
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
-  merged_event = host_->coalesced_gesture_events_.back();
+  merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
-  EXPECT_FALSE(host_->fling_in_progress_);
-  EXPECT_EQ(4U, host_->coalesced_gesture_events_.size());
+  EXPECT_FALSE(host_->FlingInProgress());
+  EXPECT_EQ(4U, host_->GestureEventLastQueueEventSize());
 
   // Adding another GFC with a GFC already there is dropped.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
-  merged_event = host_->coalesced_gesture_events_.back();
+  merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
-  EXPECT_FALSE(host_->fling_in_progress_);
-  EXPECT_EQ(4U, host_->coalesced_gesture_events_.size());
+  EXPECT_FALSE(host_->FlingInProgress());
+  EXPECT_EQ(4U, host_->GestureEventLastQueueEventSize());
 }
 
 // Test that the hang monitor timer expires properly if a new timer is started

content/content_browser.gypi

@@ -538,6 +538,8 @@
     'browser/renderer_host/file_utilities_message_filter.h',
     'browser/renderer_host/gamepad_browser_message_filter.cc',
     'browser/renderer_host/gamepad_browser_message_filter.h',
+    'browser/renderer_host/gesture_event_filter.cc',
+    'browser/renderer_host/gesture_event_filter.h',
     'browser/renderer_host/gpu_message_filter.cc',
     'browser/renderer_host/gpu_message_filter.h',
     'browser/renderer_host/gtk_im_context_wrapper.cc',