Signal input flush when all flings have terminated

content/browser/renderer_host/input/input_router_impl.cc

 // Copyright 2013 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/input/input_router_impl.h"
 
 #include <math.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 58 matching lines @@
       client_(client),
       ack_handler_(ack_handler),
       routing_id_(routing_id),
       select_message_pending_(false),
       move_caret_pending_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       current_view_flags_(0),
       current_ack_source_(ACK_SOURCE_NONE),
       flush_requested_(false),
+      active_fling_count_(0),
       touch_event_queue_(this, config.touch_config),
       gesture_event_queue_(this, this, config.gesture_config) {
   DCHECK(sender);
   DCHECK(client);
   DCHECK(ack_handler);
   UpdateTouchAckTimeoutEnabled();
 }
 
 InputRouterImpl::~InputRouterImpl() {
   STLDeleteElements(&pending_select_messages_);
 }
 
-void InputRouterImpl::Flush() {
-  flush_requested_ = true;
-  SignalFlushedIfNecessary();
-}
-
 bool InputRouterImpl::SendInput(scoped_ptr<IPC::Message> message) {
   DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
   switch (message->type()) {
     // Check for types that require an ACK.
     case InputMsg_SelectRange::ID:
     case InputMsg_MoveRangeSelectionExtent::ID:
       return SendSelectMessage(message.Pass());
     case InputMsg_MoveCaret::ID:
       return SendMoveCaret(message.Pass());
     case InputMsg_HandleInputEvent::ID:
@@ skipping 131 matching lines @@
   return &key_queue_.front();
 }
 
 void InputRouterImpl::OnViewUpdated(int view_flags) {
   current_view_flags_ = view_flags;
 
   // A fixed page scale or mobile viewport should disable the touch ack timeout.
   UpdateTouchAckTimeoutEnabled();
 }
 
+void InputRouterImpl::RequestNotificationWhenFlushed() {
+  flush_requested_ = true;
+  SignalFlushedIfNecessary();
+}
+
+bool InputRouterImpl::HasPendingEvents() const {
+  return !touch_event_queue_.empty() ||
+         !gesture_event_queue_.empty() ||
+         !key_queue_.empty() ||
+         mouse_move_pending_ ||
+         mouse_wheel_pending_ ||
+         select_message_pending_ ||
+         move_caret_pending_ ||
+         active_fling_count_ > 0;
+}
+
 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(InputRouterImpl, message)
     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_DidOverscroll, OnDidOverscroll)
     IPC_MESSAGE_HANDLER(InputHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_SelectRange_ACK, OnSelectMessageAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_MoveRangeSelectionExtent_ACK,
                         OnSelectMessageAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
                         OnSetTouchAction)
+    IPC_MESSAGE_HANDLER(InputHostMsg_DidStopFlinging, OnFlingingStopped)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void InputRouterImpl::OnTouchEventAck(const TouchEventWithLatencyInfo& event,
                                       InputEventAckState ack_result) {
   // Touchstart events sent to the renderer indicate a new touch sequence, but
   // in some cases we may filter out sending the touchstart - catch those here.
@@ skipping 208 matching lines @@
   DCHECK(touch_event_queue_.IsPendingAckTouchStart());
   TRACE_EVENT1("input", "InputRouterImpl::OnSetTouchAction",
                "action", touch_action);
 
   touch_action_filter_.OnSetTouchAction(touch_action);
 
   // TOUCH_ACTION_NONE should disable the touch ack timeout.
   UpdateTouchAckTimeoutEnabled();
 }
 
+void InputRouterImpl::OnFlingingStopped() {
+  DCHECK_GT(active_fling_count_, 0);
+  --active_fling_count_;
+  SignalFlushedIfNecessary();
+  client_->DidStopFlinging();
+}
+
 void InputRouterImpl::ProcessInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info,
     AckSource ack_source) {
   TRACE_EVENT2("input", "InputRouterImpl::ProcessInputEventAck",
                "type", WebInputEventTraits::GetName(event_type),
                "ack", GetEventAckName(ack_result));
 
   // Note: The keyboard ack must be treated carefully, as it may result in
@@ skipping 81 matching lines @@
     MouseWheelEventWithLatencyInfo next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     SendWheelEvent(next_wheel_event);
   }
 }
 
 void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
                                         InputEventAckState ack_result,
                                         const ui::LatencyInfo& latency) {
+  if (type == blink::WebInputEvent::GestureFlingStart &&
+      ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) {
+    ++active_fling_count_;
+  }

[Yufeng Shen (Slow to review), 2015/03/13 15:53:42]

I saw that gesture event queue also maintains a fling_in_progress bit. Can it
and active_fling_count_ somehow be merged into one ?

[jdduke (slow), 2015/03/13 16:08:04]

Probably, although the gesture queue fling in progress bit is a little
different, as it simply tracks whether we should discard a GestureFlingCancel at
the *end* of the queue. So if a fling is active and a GestureFlingCancel is
enqueued but not sent, it will think there's no fling in progress. It should
really be named "needs_fling_cancel_".

I'll see if I can merge the two, it might mean making the GEQ filter events when
they hit the head of the queue, rather than the tail. Will post back here.

+
   // |gesture_event_queue_| will forward to OnGestureEventAck when appropriate.
   gesture_event_queue_.ProcessGestureAck(ack_result, type, latency);
 }
 
 void InputRouterImpl::ProcessTouchAck(
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   touch_event_queue_.ProcessTouchAck(ack_result, latency);
 }
@@ skipping 20 matching lines @@
   if (!flush_requested_)
     return;
 
   if (HasPendingEvents())
     return;
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
-bool InputRouterImpl::HasPendingEvents() const {
-  return !touch_event_queue_.empty() ||
-         !gesture_event_queue_.empty() ||
-         !key_queue_.empty() ||
-         mouse_move_pending_ ||
-         mouse_wheel_pending_ ||
-         select_message_pending_ ||
-         move_caret_pending_;
-}
-
 }  // namespace content