[Android] Properly disable the touch ack timeout during a touch sequence

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/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
@@ skipping 29 matching lines @@
          type == WebInputEvent::TouchMove;
 }
 
 }  // namespace
 
 
 // Cancels a touch sequence if a touchstart or touchmove ack response is
 // sufficiently delayed.
 class TouchEventQueue::TouchTimeoutHandler {
  public:
-  TouchTimeoutHandler(TouchEventQueue* touch_queue, size_t timeout_delay_ms)
+  TouchTimeoutHandler(TouchEventQueue* touch_queue,
+                      base::TimeDelta timeout_delay)
       : touch_queue_(touch_queue),
-        timeout_delay_(base::TimeDelta::FromMilliseconds(timeout_delay_ms)),
+        timeout_delay_(timeout_delay),
         pending_ack_state_(PENDING_ACK_NONE),
         timeout_monitor_(base::Bind(&TouchTimeoutHandler::OnTimeOut,
                                     base::Unretained(this))) {}
 
   ~TouchTimeoutHandler() {}
 
   void Start(const TouchEventWithLatencyInfo& event) {
     DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
     DCHECK(ShouldTouchTypeTriggerTimeout(event.event.type));
     timeout_event_ = event;
@@ skipping 29 matching lines @@
 
   bool IsTimeoutTimerRunning() const {
     return timeout_monitor_.IsRunning();
   }
 
   void Reset() {
     pending_ack_state_ = PENDING_ACK_NONE;
     timeout_monitor_.Stop();
   }
 
+  void set_timeout_delay(base::TimeDelta timeout_delay) {
+    timeout_delay_ = timeout_delay;
+  }
+
  private:
   enum PendingAckState {
     PENDING_ACK_NONE,
     PENDING_ACK_ORIGINAL_EVENT,
     PENDING_ACK_CANCEL_EVENT,
   };
 
   void OnTimeOut() {
     TRACE_EVENT1("input", "TouchEventQueue::TouchTimedOut",
                  "type", WebInputEventTraits::GetName(timeout_event_.event.type));
@@ skipping 387 matching lines @@
   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);
 }
 
 void TouchEventQueue::SetAckTimeoutEnabled(bool enabled,
-                                           size_t ack_timeout_delay_ms) {
+                                           base::TimeDelta ack_timeout_delay) {
   if (!enabled) {
-    // Avoid resetting |timeout_handler_|, as an outstanding timeout may
-    // be active and must be completed for ack handling consistency.
     ack_timeout_enabled_ = false;
+    if (touch_filtering_state_ == FORWARD_TOUCHES_UNTIL_TIMEOUT)
+      touch_filtering_state_ = FORWARD_ALL_TOUCHES;
+    // 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 (timeout_handler_ && timeout_handler_->IsTimeoutTimerRunning())
+      timeout_handler_->Reset();
     return;
   }
 
   ack_timeout_enabled_ = true;
   if (!timeout_handler_)
-    timeout_handler_.reset(new TouchTimeoutHandler(this, ack_timeout_delay_ms));
+    timeout_handler_.reset(new TouchTimeoutHandler(this, ack_timeout_delay));
+  else
+    timeout_handler_->set_timeout_delay(ack_timeout_delay);
 }
 
 bool TouchEventQueue::IsTimeoutRunningForTesting() const {
   return timeout_handler_ && timeout_handler_->IsTimeoutTimerRunning();
 }
 
 const TouchEventWithLatencyInfo&
 TouchEventQueue::GetLatestEventForTesting() const {
   return touch_queue_.back()->coalesced_event();
 }
@@ skipping 94 matching lines @@
   } else if (event.type == WebInputEvent::TouchStart) {
     for (unsigned i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StatePressed)
         touch_ack_states_[point.id] = ack_result;
     }
   }
 }
 
 }  // namespace content