Remove the touch ack timeout handler out of the legacy touch event queue.

content/browser/renderer_host/input/legacy_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/legacy_touch_event_queue.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
-#include "content/browser/renderer_host/input/timeout_monitor.h"
+#include "content/browser/renderer_host/input/touch_timeout_handler.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/gfx/geometry/point_f.h"
 
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
 // Time interval at which touchmove events will be forwarded to the client while
 // scrolling is active and possible.
 const double kAsyncTouchMoveIntervalSec = .2;
 
-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;
-}
-
-bool ShouldTouchTriggerTimeout(const WebTouchEvent& event) {
-  return (event.type() == WebInputEvent::TouchStart ||
-          event.type() == WebInputEvent::TouchMove) &&
-         event.dispatchType == WebInputEvent::Blocking;
-}
-
 // Compare all properties of touch points to determine the state.
 bool HasPointChanged(const WebTouchPoint& point_1,
                      const WebTouchPoint& point_2) {
   DCHECK_EQ(point_1.id, point_2.id);
   if (point_1.screenPosition != point_2.screenPosition ||
       point_1.position != point_2.position ||
       point_1.radiusX != point_2.radiusX ||
       point_1.radiusY != point_2.radiusY ||
       point_1.rotationAngle != point_2.rotationAngle ||
       point_1.force != point_2.force || point_1.tiltX != point_2.tiltX ||
       point_1.tiltY != point_2.tiltY) {
     return true;
   }
   return false;
 }
 
 }  // namespace
 
-// Cancels a touch sequence if a touchstart or touchmove ack response is
-// sufficiently delayed.
-class LegacyTouchEventQueue::TouchTimeoutHandler {
- public:
-  TouchTimeoutHandler(LegacyTouchEventQueue* touch_queue,
-                      base::TimeDelta desktop_timeout_delay,
-                      base::TimeDelta mobile_timeout_delay)
-      : touch_queue_(touch_queue),
-        desktop_timeout_delay_(desktop_timeout_delay),
-        mobile_timeout_delay_(mobile_timeout_delay),
-        use_mobile_timeout_(false),
-        pending_ack_state_(PENDING_ACK_NONE),
-        timeout_monitor_(base::Bind(&TouchTimeoutHandler::OnTimeOut,
-                                    base::Unretained(this))),
-        enabled_(true),
-        enabled_for_current_sequence_(false),
-        sequence_awaiting_uma_update_(false),
-        sequence_using_mobile_timeout_(false) {
-    SetUseMobileTimeout(false);
-  }
-
-  ~TouchTimeoutHandler() { LogSequenceEndForUMAIfNecessary(false); }
-
-  void StartIfNecessary(const TouchEventWithLatencyInfo& event) {
-    if (pending_ack_state_ != PENDING_ACK_NONE)
-      return;
-
-    if (!enabled_)
-      return;
-
-    const base::TimeDelta timeout_delay = GetTimeoutDelay();
-    if (timeout_delay.is_zero())
-      return;
-
-    if (!ShouldTouchTriggerTimeout(event.event))
-      return;
-
-    if (WebTouchEventTraits::IsTouchSequenceStart(event.event)) {
-      LogSequenceStartForUMA();
-      enabled_for_current_sequence_ = true;
-    }
-
-    if (!enabled_for_current_sequence_)
-      return;
-
-    timeout_event_ = event;
-    timeout_monitor_.Restart(timeout_delay);
-  }
-
-  bool ConfirmTouchEvent(InputEventAckState ack_result) {
-    switch (pending_ack_state_) {
-      case PENDING_ACK_NONE:
-        if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
-          enabled_for_current_sequence_ = false;
-        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) {
-    if (!HasTimeoutEvent())
-      return false;
-
-    if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
-      // If a new sequence is observed while we're still waiting on the
-      // timed-out sequence response, also count the new sequence as timed-out.
-      LogSequenceStartForUMA();
-      LogSequenceEndForUMAIfNecessary(true);
-    }
-
-    return true;
-  }
-
-  void SetEnabled(bool enabled) {
-    if (enabled_ == enabled)
-      return;
-
-    enabled_ = enabled;
-
-    if (enabled_)
-      return;
-
-    enabled_for_current_sequence_ = false;
-    // Only reset the |timeout_handler_| if the timer is running and has not
-    // yet timed out. This ensures that an already timed out sequence is
-    // properly flushed by the handler.
-    if (IsTimeoutTimerRunning()) {
-      pending_ack_state_ = PENDING_ACK_NONE;
-      timeout_monitor_.Stop();
-    }
-  }
-
-  void SetUseMobileTimeout(bool use_mobile_timeout) {
-    use_mobile_timeout_ = use_mobile_timeout;
-  }
-
-  bool IsTimeoutTimerRunning() const { return timeout_monitor_.IsRunning(); }
-
-  bool IsEnabled() const { return enabled_ && !GetTimeoutDelay().is_zero(); }
-
- private:
-  enum PendingAckState {
-    PENDING_ACK_NONE,
-    PENDING_ACK_ORIGINAL_EVENT,
-    PENDING_ACK_CANCEL_EVENT,
-  };
-
-  void OnTimeOut() {
-    LogSequenceEndForUMAIfNecessary(true);
-    SetPendingAckState(PENDING_ACK_ORIGINAL_EVENT);
-    touch_queue_->FlushQueue();
-  }
-
-  // Skip a cancel event if the timed-out event had no consumer and was the
-  // initial event in the gesture.
-  bool AckedTimeoutEventRequiresCancel(InputEventAckState ack_result) const {
-    DCHECK(HasTimeoutEvent());
-    if (ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
-      return true;
-    return !WebTouchEventTraits::IsTouchSequenceStart(timeout_event_.event);
-  }
-
-  void SetPendingAckState(PendingAckState new_pending_ack_state) {
-    DCHECK_NE(pending_ack_state_, new_pending_ack_state);
-    switch (new_pending_ack_state) {
-      case PENDING_ACK_ORIGINAL_EVENT:
-        DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
-        TRACE_EVENT_ASYNC_BEGIN0("input", "TouchEventTimeout", this);
-        break;
-      case PENDING_ACK_CANCEL_EVENT:
-        DCHECK_EQ(pending_ack_state_, PENDING_ACK_ORIGINAL_EVENT);
-        DCHECK(!timeout_monitor_.IsRunning());
-        DCHECK(touch_queue_->empty());
-        TRACE_EVENT_ASYNC_STEP_INTO0("input", "TouchEventTimeout", this,
-                                     "CancelEvent");
-        break;
-      case PENDING_ACK_NONE:
-        DCHECK(!timeout_monitor_.IsRunning());
-        DCHECK(touch_queue_->empty());
-        TRACE_EVENT_ASYNC_END0("input", "TouchEventTimeout", this);
-        break;
-    }
-    pending_ack_state_ = new_pending_ack_state;
-  }
-
-  void LogSequenceStartForUMA() {
-    // Always flush any unlogged entries before starting a new one.
-    LogSequenceEndForUMAIfNecessary(false);
-    sequence_awaiting_uma_update_ = true;
-    sequence_using_mobile_timeout_ = use_mobile_timeout_;
-  }
-
-  void LogSequenceEndForUMAIfNecessary(bool timed_out) {
-    if (!sequence_awaiting_uma_update_)
-      return;
-
-    sequence_awaiting_uma_update_ = false;
-
-    if (sequence_using_mobile_timeout_) {
-      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;
-  }
-
-  LegacyTouchEventQueue* 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_;
-
-  // The event for which the ack timeout is triggered.
-  TouchEventWithLatencyInfo timeout_event_;
-
-  // Provides timeout-based callback behavior.
-  TimeoutMonitor timeout_monitor_;
-
-  bool enabled_;
-  bool enabled_for_current_sequence_;
-
-  // Bookkeeping to classify and log whether a touch sequence times out.
-  bool sequence_awaiting_uma_update_;
-  bool sequence_using_mobile_timeout_;
-};
-
 // This class represents a single coalesced touch event. However, it also keeps
 // track of all the original touch-events that were coalesced into a single
 // event. The coalesced event is forwarded to the renderer, while the original
 // touch-events are sent to the Client (on ACK for the coalesced event) so that
 // the Client receives the event with their original timestamp.
 class CoalescedWebTouchEvent {
  public:
   CoalescedWebTouchEvent(const TouchEventWithLatencyInfo& event,
                          bool suppress_client_ack)
       : coalesced_event_(event), suppress_client_ack_(suppress_client_ack) {
@@ skipping 177 matching lines @@
           last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec) {
         FlushPendingAsyncTouchmove();
       }
     }
     return;
   }
 
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
-  if (timeout_handler_ && timeout_handler_->ConfirmTouchEvent(ack_result))
+  if (timeout_handler_ &&
+      timeout_handler_->ConfirmTouchEvent(unique_touch_event_id, ack_result))
     return;
 
   if (touch_queue_.empty())
     return;
 
   // We don't care about the ordering of the acks vs the ordering of the
   // dispatched events because we can receive the ack for event B before the ack
   // for event A even though A was sent before B. This seems to be happening
   // when, for example, A is acked from renderer but B isn't, so the ack for B
   // is synthesized "locally" in InputRouter.
@@ skipping 226 matching lines @@
   // Skip ack for TouchScrollStarted since it was synthesized within the queue.
   if (acked_event->coalesced_event().event.type() !=
       WebInputEvent::TouchScrollStarted) {
     acked_event->DispatchAckToClient(ack_result, optional_latency_info,
                                      client_);
   }
 
   touch_queue_.pop_front();
 }
 
+void LegacyTouchEventQueue::SendTouchCancelEventForTouchEvent(
+    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);
+  SendTouchEventImmediately(&event);
+}
+
 void LegacyTouchEventQueue::SendTouchEventImmediately(
     TouchEventWithLatencyInfo* touch) {
   // TODO(crbug.com/600773): Hack to avoid cyclic reentry to this method.
   if (dispatching_touch_)
     return;
 
   if (touch->event.type() == WebInputEvent::TouchStart)
     touch->event.touchStartOrFirstTouchMove = true;
 
   // For touchmove events, compare touch points position from current event
@@ skipping 55 matching lines @@
 LegacyTouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
   if (event.type() == WebInputEvent::TouchScrollStarted)
     return FORWARD_TO_RENDERER;
 
   if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
     has_handler_for_current_sequence_ = false;
     send_touch_events_async_ = false;
     pending_async_touchmove_.reset();
     last_sent_touchevent_.reset();
 
-    touch_sequence_start_position_ = gfx::PointF(event.touches[0].position);
     drop_remaining_touches_in_sequence_ = false;
     if (!has_handlers_) {
       drop_remaining_touches_in_sequence_ = true;
       return ACK_WITH_NO_CONSUMER_EXISTS;
     }
   }
 
   if (timeout_handler_ && timeout_handler_->FilterEvent(event))
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
@@ skipping 52 matching lines @@
     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;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content