Refactoring: Extract gesture event filtering into helper class.

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 <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #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"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/tap_suppression_controller.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/port/browser/smooth_scroll_gesture.h"
@@ skipping 52 matching lines @@
 bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
                                     const WebMouseWheelEvent& new_event) {
   return last_event.modifiers == new_event.modifiers &&
          last_event.scrollByPage == new_event.scrollByPage &&
          last_event.hasPreciseScrollingDeltas
              == new_event.hasPreciseScrollingDeltas &&
          last_event.phase == new_event.phase &&
          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
 
 
 // static
 void RenderWidgetHost::RemoveAllBackingStores() {
   BackingStoreManager::RemoveAllBackingStores();
 }
 
 // static
 size_t RenderWidgetHost::BackingStoreMemorySize() {
@@ skipping 15 matching lines @@
       surface_id_(0),
       is_loading_(false),
       is_hidden_(false),
       is_fullscreen_(false),
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       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),
       in_get_backing_store_(false),
       abort_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),
       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)),
-      fling_in_progress_(false) {
+      gesture_event_filter_(new GestureEventFilter(this)) {
   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 321 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;
+  gesture_event_filter_->FlingHasBeenHalted();
   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 355 matching lines @@
         int x = next_mouse_move_->movementX;
         int y = next_mouse_move_->movementY;
         *next_mouse_move_ = mouse_event;
         next_mouse_move_->movementX += x;
         next_mouse_move_->movementY += y;
       }
       return;
     }
     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;
   }
 
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
 }
 
 void RenderWidgetHostImpl::OnPointerEventActivate() {
 }
 
 void RenderWidgetHostImpl::ForwardWheelEvent(
@@ skipping 29 matching lines @@
 
   HISTOGRAM_COUNTS_100("MPArch.RWH_WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
   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())
+  if (ignore_input_events_ || process_->IgnoreInputEvents() ||
+      !gesture_event_filter_->ShouldForward(gesture_event))
     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;
-    }
-    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);
 }
 
 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.
+    gesture_event_filter_->FlingHasBeenHalted();
 
     // 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) {
@@ skipping 78 matching lines @@
   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;
   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();
   suppress_next_char_events_ = false;
 
   // Reset some fields in preparation for recovering from a crash.
   resize_ack_pending_ = false;
   repaint_ack_pending_ = false;
 
   in_flight_size_.SetSize(0, 0);
@@ skipping 481 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);
   }
 
   if (!processed && !is_hidden_ && view_)
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
 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(
     WebInputEvent::Type type, bool processed) {
   if (view_)
     view_->ProcessTouchAck(type, processed);
 }
 
 void RenderWidgetHostImpl::OnMsgFocus() {
   // Only RenderViewHost can deal with that message.
@@ skipping 369 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