Filter unnecessary GestureFlingCancel events.

content/browser/renderer_host/render_widget_host_impl.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/render_widget_host_impl.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 84 matching lines @@
 // 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
 
+
 // static
 void RenderWidgetHost::RemoveAllBackingStores() {
   BackingStoreManager::RemoveAllBackingStores();
 }
 
 // static
 size_t RenderWidgetHost::BackingStoreMemorySize() {
   return BackingStoreManager::MemorySize();
 }
 
@@ skipping 28 matching lines @@
       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),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
-      tap_suppression_controller_(new TapSuppressionController(this)) {
+      tap_suppression_controller_(new TapSuppressionController(this)),
+      fling_in_progress_(false) {
   CHECK(delegate_);
   if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
     surface_id_ = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
         process_->GetID(),
         routing_id_);
   } else {
     // TODO(piman): This is a O(N) lookup, where we could forward the
     // information from the RenderWidgetHelper. The problem is that doing so
     // currently leaks outside of content all the way to chrome classes, and
@@ skipping 319 matching lines @@
 void RenderWidgetHostImpl::ViewDestroyed() {
   RejectMouseLockOrUnlockIfNecessary();
 
   // TODO(evanm): tracking this may no longer be necessary;
   // eliminate this function if so.
   SetView(NULL);
 }
 
 void RenderWidgetHostImpl::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
+  fling_in_progress_ = false;
   if (!view_)
     return;
   view_->SetIsLoading(is_loading);
 }
 
 void RenderWidgetHostImpl::CopyFromBackingStore(
     const gfx::Rect& src_subrect,
     const gfx::Size& accelerated_dst_size,
     const base::Callback<void(bool)>& callback,
     skia::PlatformCanvas* output) {
@@ skipping 320 matching lines @@
 
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
 }
 
 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() ||
+    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;
   }
   gesture_event_pending_ = true;
 
-  if (gesture_event.type == WebInputEvent::GestureFlingCancel)
+  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);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (key_event.type == WebKeyboardEvent::Char &&
@@ skipping 42 matching lines @@
     // Don't add this key to the queue if we have no way to send the message...
     if (!process_->HasConnection())
       return;
 
     // Put all WebKeyboardEvent objects in a queue since we can't trust the
     // renderer and we need to give something to the HandleKeyboardEvent
     // handler.
     key_queue_.push_back(key_event);
     HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
+    fling_in_progress_ = false; // Key events always stop flings.
+
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
                       is_keyboard_shortcut);
   }
 }
 
 void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
                                              int event_size,
                                              bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardInputEvent");
@@ skipping 580 matching lines @@
       base::TimeDelta::FromMilliseconds(kSyntheticScrollMessageIntervalMs));
 
 
   bool active = active_smooth_scroll_gesture_->ForwardInputEvents(now, this);
   if (!active) {
     active_smooth_scroll_gesture_.reset();
     // TODO(nduca): send "smooth scroll done" event to RenderWidget.
   }
 }
 
+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;
 
   // 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 408 matching lines @@
   // indicate that no callback is in progress (i.e. without this line
   // DelayedAutoResized will not get called again).
   new_auto_size_.SetSize(0, 0);
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 }  // namespace content