Delegate touch handler registration logic to the TouchEventQueue

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 82 matching lines @@
                                  InputAckHandler* ack_handler,
                                  int routing_id)
     : sender_(sender),
       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),
-      has_touch_handler_(false),
       touch_ack_timeout_enabled_(false),
       touch_ack_timeout_delay_ms_(std::numeric_limits<size_t>::max()),
       current_ack_source_(ACK_SOURCE_NONE),
       gesture_event_filter_(new GestureEventFilter(this, this)) {
   DCHECK(sender);
   DCHECK(client);
   DCHECK(ack_handler);
   touch_event_queue_.reset(new TouchEventQueue(this));
   touch_ack_timeout_enabled_ =
       GetTouchAckTimeoutDelayMs(&touch_ack_timeout_delay_ms_);
@@ skipping 138 matching lines @@
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 const NativeWebKeyboardEvent* InputRouterImpl::GetLastKeyboardEvent() const {
   if (key_queue_.empty())
     return NULL;
   return &key_queue_.front();
 }
 
 bool InputRouterImpl::ShouldForwardTouchEvent() const {
-  // Always send a touch event if the renderer has a touch-event handler. It is
-  // possible that a renderer stops listening to touch-events while there are
-  // still events in the touch-queue. In such cases, the new events should still
-  // get into the queue.
-  return has_touch_handler_ || !touch_event_queue_->empty();
+  // Always send a touch event if the renderer has a touch-event handler.
+  return touch_event_queue_->has_handlers();
 }
 
 void InputRouterImpl::OnViewUpdated(int view_flags) {
   bool fixed_page_scale = (view_flags & FIXED_PAGE_SCALE) != 0;
   bool mobile_viewport = (view_flags & MOBILE_VIEWPORT) != 0;
   touch_event_queue_->SetAckTimeoutEnabled(
       touch_ack_timeout_enabled_ && !(fixed_page_scale || mobile_viewport),
       touch_ack_timeout_delay_ms_);
 }
 
@@ skipping 218 matching lines @@
     SendMoveCaret(next_move_caret_.Pass());
 }
 
 void InputRouterImpl::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_)
     SendSelectRange(next_selection_range_.Pass());
 }
 
 void InputRouterImpl::OnHasTouchEventHandlers(bool has_handlers) {
- if (has_touch_handler_ == has_handlers)
+  if (has_handlers == touch_event_queue_->has_handlers())
     return;
-  has_touch_handler_ = has_handlers;
-  if (!has_handlers)
-    touch_event_queue_->FlushQueue();
+  touch_event_queue_->OnHasTouchEventHandlers(has_handlers);
   client_->OnHasTouchEventHandlers(has_handlers);
 }
 
 void InputRouterImpl::OnSetTouchAction(
     content::TouchAction touch_action) {
   // Synthetic touchstart events should get filtered out in RenderWidget.
   DCHECK(touch_event_queue_->IsPendingAckTouchStart());
 
   touch_action_filter_.OnSetTouchAction(touch_action);
 }
@@ skipping 204 matching lines @@
       break;
   }
 }
 
 bool InputRouterImpl::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content