Defer synthetic gesture completions until events have been flushed

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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 128 matching lines @@
       client_(client),
       ack_handler_(ack_handler),
       routing_id_(routing_id),
       select_range_pending_(false),
       move_caret_pending_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       touch_ack_timeout_supported_(false),
       current_view_flags_(0),
       current_ack_source_(ACK_SOURCE_NONE),
+      flush_requested_(false),
       gesture_event_queue_(new GestureEventQueue(this, this)) {
   DCHECK(sender);
   DCHECK(client);
   DCHECK(ack_handler);
   touch_event_queue_.reset(new TouchEventQueue(
       this, GetTouchScrollingMode(), GetTouchMoveSlopSuppressionLengthDips()));
   touch_ack_timeout_supported_ =
       GetTouchAckTimeoutDelay(&touch_ack_timeout_delay_);
   UpdateTouchAckTimeoutEnabled();
 }
 
 InputRouterImpl::~InputRouterImpl() {}
 
-void InputRouterImpl::Flush() {}
+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:
       return SendSelectRange(message.Pass());
     case InputMsg_MoveCaret::ID:
       return SendMoveCaret(message.Pass());
     case InputMsg_HandleInputEvent::ID:
@@ skipping 443 matching lines @@
     ProcessMouseAck(event_type, ack_result);
   } else if (event_type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(ack_result, latency_info);
   } else if (WebInputEvent::isTouchEventType(event_type)) {
     ProcessTouchAck(ack_result, latency_info);
   } else if (WebInputEvent::isGestureEventType(event_type)) {
     ProcessGestureAck(event_type, ack_result, latency_info);
   } else if (event_type != WebInputEvent::Undefined) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
   }
+
+  SignalFlushedIfNecessary();
 }
 
 void InputRouterImpl::ProcessKeyboardAck(blink::WebInputEvent::Type type,
                                          InputEventAckState ack_result) {
   if (key_queue_.empty()) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
   } else if (key_queue_.front().type != type) {
     // Something must be wrong. Clear the |key_queue_| and char event
     // suppression so that we can resume from the error.
     key_queue_.clear();
@@ skipping 179 matching lines @@
   const bool touch_action_none =
       touch_action_filter_.allowed_touch_action() == TOUCH_ACTION_NONE;
 
   const bool touch_ack_timeout_enabled = !fixed_page_scale &&
                                          !mobile_viewport &&
                                          !touch_action_none;
   touch_event_queue_->SetAckTimeoutEnabled(touch_ack_timeout_enabled,
                                            touch_ack_timeout_delay_);
 }
 
+void InputRouterImpl::SignalFlushedIfNecessary() {
+  if (!flush_requested_)
+    return;
+
+  if (HasPendingEvents())
+    return;
+
+  flush_requested_ = false;
+  client_->DidFlush();
+}
+
+bool InputRouterImpl::HasPendingEvents() const {
+  return !touch_event_queue_->empty() ||
+         gesture_event_queue_->HasQueuedGestureEvents() ||
+         !key_queue_.empty() ||
+         mouse_move_pending_ ||
+         mouse_wheel_pending_ ||
+         select_range_pending_ ||
+         move_caret_pending_;
+}
+
 bool InputRouterImpl::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content