Route touchmove existence notifications to the TouchEventQueue

content/browser/renderer_host/input/touch_event_queue.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/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 11 matching lines @@
 
 // Time interval at which touchmove events will be forwarded to the client while
 // scrolling is active and possible.
 const double kAsyncTouchMoveIntervalSec = .2;
 
 // A sanity check on touches received to ensure that touch movement outside
 // the platform slop region will cause scrolling, as indicated by the event's
 // |causesScrollingIfUncanceled| bit.
 const double kMaxConceivablePlatformSlopRegionLengthDipsSquared = 60. * 60.;
 
+// These values should be synchronized with those in histograms.xml.
+enum TouchSequenceHandlerType {
+  HAS_HANDLER,
+  HAS_HANDLER_BUT_NO_MOVE_HANDLERS_FOR_PAGE,
+  NO_HANDLERS_FOR_PAGE,
+  NO_HANDLER_FOR_SEQUENCE,
+  UNKNOWN_BECAUSE_TIMEOUT,
+  TOUCH_SEQUENCE_HANDLER_TYPE_COUNT
+};
+
+void LogSequenceHandlerType(TouchSequenceHandlerType type) {
+  UMA_HISTOGRAM_ENUMERATION("Event.TouchSequence.HandlerType", type,
+                            TOUCH_SEQUENCE_HANDLER_TYPE_COUNT);
+}
+
 TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
     const TouchEventWithLatencyInfo& event_to_cancel) {
   TouchEventWithLatencyInfo event = event_to_cancel;
   WebTouchEventTraits::ResetTypeAndTouchStates(
       WebInputEvent::TouchCancel,
       // TODO(rbyers): Shouldn't we use a fresh timestamp?
       event.event.timeStampSeconds,
       &event.event);
   return event;
 }
@@ skipping 82 matching lines @@
         timeout_monitor_.Stop();
         return false;
       case PENDING_ACK_ORIGINAL_EVENT:
         if (AckedTimeoutEventRequiresCancel(ack_result)) {
           SetPendingAckState(PENDING_ACK_CANCEL_EVENT);
           TouchEventWithLatencyInfo cancel_event =
               ObtainCancelEventForTouchEvent(timeout_event_);
           touch_queue_->SendTouchEventImmediately(&cancel_event);
         } else {
           SetPendingAckState(PENDING_ACK_NONE);
-          touch_queue_->UpdateTouchConsumerStates(timeout_event_.event,
-                                                  ack_result);
         }
         return true;
       case PENDING_ACK_CANCEL_EVENT:
         SetPendingAckState(PENDING_ACK_NONE);
         return true;
     }
     return false;
   }
 
   bool FilterEvent(const WebTouchEvent& event) {
@@ skipping 28 matching lines @@
       timeout_monitor_.Stop();
     }
   }
 
   void SetUseMobileTimeout(bool use_mobile_timeout) {
     use_mobile_timeout_ = use_mobile_timeout;
   }
 
   bool IsTimeoutTimerRunning() const { return timeout_monitor_.IsRunning(); }
 
+  bool HasTimeoutEvent() const {
+    return pending_ack_state_ != PENDING_ACK_NONE;
+  }
+
   bool IsEnabled() const {
     return enabled_ && !GetTimeoutDelay().is_zero();
   }
 
  private:
   enum PendingAckState {
     PENDING_ACK_NONE,
     PENDING_ACK_ORIGINAL_EVENT,
     PENDING_ACK_CANCEL_EVENT,
   };
@@ skipping 53 matching lines @@
       UMA_HISTOGRAM_BOOLEAN("Event.Touch.TimedOutOnMobileSite", timed_out);
     } else {
       UMA_HISTOGRAM_BOOLEAN("Event.Touch.TimedOutOnDesktopSite", timed_out);
     }
   }
 
   base::TimeDelta GetTimeoutDelay() const {
     return use_mobile_timeout_ ? mobile_timeout_delay_ : desktop_timeout_delay_;
   }
 
-  bool HasTimeoutEvent() const {
-    return pending_ack_state_ != PENDING_ACK_NONE;
-  }
-
 
   TouchEventQueue* touch_queue_;
 
   // How long to wait on a touch ack before cancelling the touch sequence.
   const base::TimeDelta desktop_timeout_delay_;
   const base::TimeDelta mobile_timeout_delay_;
   bool use_mobile_timeout_;
 
   // The touch event source for which we expect the next ack.
   PendingAckState pending_ack_state_;
@@ skipping 155 matching lines @@
       mobile_touch_ack_timeout_delay(base::TimeDelta::FromMilliseconds(1000)),
       touch_ack_timeout_supported(false) {
 }
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client,
                                  const Config& config)
     : client_(client),
       dispatching_touch_ack_(false),
       dispatching_touch_(false),
       has_handlers_(true),
+      has_move_handlers_(true),
       has_handler_for_current_sequence_(false),
       drop_remaining_touches_in_sequence_(false),
       touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
       last_sent_touch_timestamp_sec_(0) {
   DCHECK(client);
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this,
                                 config.desktop_touch_ack_timeout_delay,
                                 config.mobile_touch_ack_timeout_delay));
   }
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");
 
   // If the queueing of |event| was triggered by an ack dispatch, defer
   // processing the event until the dispatch has finished.
   if (touch_queue_.empty() && !dispatching_touch_ack_) {
     // Optimization of the case without touch handlers.  Removing this path
     // yields identical results, but this avoids unnecessary allocations.
     PreFilterResult filter_result = FilterBeforeForwarding(event.event);
     if (filter_result != FORWARD_TO_RENDERER) {
-      client_->OnTouchEventAck(event,
-                               filter_result == ACK_WITH_NO_CONSUMER_EXISTS
-                                   ? INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS
-                                   : INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+      InputEventAckState ack_result =
+          filter_result == ACK_WITH_NO_CONSUMER_EXISTS
+              ? INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS
+              : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+      UpdateTouchConsumerStates(event.event, ack_result);
+      client_->OnTouchEventAck(event, ack_result);
       return;
     }
 
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
     touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
     ForwardNextEventToRenderer();
     return;
   }
 
@@ skipping 173 matching lines @@
   if (event.event.type == blink::WebInputEvent::GestureScrollUpdate)
     send_touch_events_async_ = (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
 }
 
 void TouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
   has_handlers_ = has_handlers;
 }
 
+void TouchEventQueue::OnHasTouchMoveEventHandlers(bool has_handlers) {
+  DCHECK(!dispatching_touch_ack_);
+  DCHECK(!dispatching_touch_);
+  has_move_handlers_ = has_handlers;
+}
+
 bool TouchEventQueue::IsPendingAckTouchStart() const {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return false;
 
   const blink::WebTouchEvent& event =
       touch_queue_.front()->coalesced_event().event;
   return (event.type == WebInputEvent::TouchStart);
 }
 
@@ skipping 144 matching lines @@
       event.type != WebInputEvent::TouchCancel) {
     return ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
   if (event.type == WebInputEvent::TouchStart) {
     return (has_handlers_ || has_handler_for_current_sequence_)
                ? FORWARD_TO_RENDERER
                : ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
+  if (event.type == WebInputEvent::TouchMove && !has_move_handlers_)
+    return ACK_WITH_NO_CONSUMER_EXISTS;
+
   if (has_handler_for_current_sequence_) {
     // Only forward a touch if it has a non-stationary pointer that is active
     // in the current touch sequence.
     for (size_t i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StateStationary)
         continue;
 
       // |last_sent_touchevent_| will be non-null as long as there is an
       // active touch sequence being forwarded to the renderer.
@@ skipping 25 matching lines @@
   return ACK_WITH_NO_CONSUMER_EXISTS;
 }
 
 void TouchEventQueue::UpdateTouchConsumerStates(const WebTouchEvent& event,
                                                 InputEventAckState ack_result) {
   if (event.type == WebInputEvent::TouchStart) {
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
+
+    if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
+      if (timeout_handler_ && timeout_handler_->HasTimeoutEvent())
+        LogSequenceHandlerType(UNKNOWN_BECAUSE_TIMEOUT);
+      else if (!has_handlers_)
+        LogSequenceHandlerType(NO_HANDLERS_FOR_PAGE);
+      else if (!has_handler_for_current_sequence_)
+        LogSequenceHandlerType(NO_HANDLER_FOR_SEQUENCE);
+      else if (!has_move_handlers_)
+        LogSequenceHandlerType(HAS_HANDLER_BUT_NO_MOVE_HANDLERS_FOR_PAGE);
+      else
+        LogSequenceHandlerType(HAS_HANDLER);
+    }
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content