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 140 matching lines @@
 
 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();
+  // still events in the touch-queue, but those events should be flushed, while
+  // subsequent touch events will never stay in the queue (at least until
+  // another touch handler is registered).
+  DCHECK(touch_event_queue_->has_handlers() || touch_event_queue_->empty());

[tdresser, 2014/01/09 21:14:32]

This DCHECK doesn't seem to make sense in conjunction with the comment above.
The comment describes how we handle the case where there are no touch handlers
but there are events in the queue, and the DCHECK states that this case will
never occur.

Does this case ever occur?

The comment is also kind of hard to parse due to sentence length.

[jdduke (slow), 2014/01/09 22:05:04]

The comment wording was poorly modified on my part.  It was supposed to mean
that we may get a "no touch handler" message while there are touch events in the
queue, which can definitely happen.  However, if that does happen, the queue
should be flushed and remain empty.

 I've shortened the comment.  Also, the DCHECK's in TouchEventQueue should be
sufficient to make the guarantee that the queue is empty if there's no touch
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