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

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 37 matching lines @@
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 
 namespace content {
 namespace {
 
 // TODO(jdduke): Instead of relying on command line flags or conditional
 // conditional compilation here, we should instead use an InputRouter::Settings
 // construct, supplied and customized by the RenderWidgetHostView. See
 // crbug.com/343917.
-bool GetTouchAckTimeoutDelayMs(size_t* touch_ack_timeout_delay_ms) {
+bool GetTouchAckTimeoutDelay(base::TimeDelta* touch_ack_timeout_delay) {
   CommandLine* parsed_command_line = CommandLine::ForCurrentProcess();
   if (!parsed_command_line->HasSwitch(switches::kTouchAckTimeoutDelayMs))
     return false;
 
   std::string timeout_string = parsed_command_line->GetSwitchValueASCII(
       switches::kTouchAckTimeoutDelayMs);
-  size_t timeout_value;
-  if (!base::StringToSizeT(timeout_string, &timeout_value))
+  size_t timeout_ms;
+  if (!base::StringToSizeT(timeout_string, &timeout_ms))
     return false;
 
-  *touch_ack_timeout_delay_ms = timeout_value;
+  *touch_ack_timeout_delay = base::TimeDelta::FromMilliseconds(timeout_ms);
   return true;
 }
 
 #if defined(OS_ANDROID)
 double GetTouchMoveSlopSuppressionLengthDips() {
   const double touch_slop_length_pixels =
       static_cast<double>(gfx::ViewConfiguration::GetTouchSlopInPixels());
   const double device_scale_factor =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().device_scale_factor();
   return touch_slop_length_pixels / device_scale_factor;
@@ skipping 59 matching lines @@
                                  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),
       touch_ack_timeout_supported_(false),
-      touch_ack_timeout_delay_ms_(std::numeric_limits<size_t>::max()),
       current_view_flags_(0),
       current_ack_source_(ACK_SOURCE_NONE),
       gesture_event_queue_(new GestureEventQueue(this, this)) {
   DCHECK(sender);
   DCHECK(client);
   DCHECK(ack_handler);
   touch_event_queue_.reset(new TouchEventQueue(
       this, GetTouchScrollingMode(), GetTouchMoveSlopSuppressionLengthDips()));
   touch_ack_timeout_supported_ =
-      GetTouchAckTimeoutDelayMs(&touch_ack_timeout_delay_ms_);
+      GetTouchAckTimeoutDelay(&touch_ack_timeout_delay_);
   UpdateTouchAckTimeoutEnabled();
 }
 
 InputRouterImpl::~InputRouterImpl() {}
 
 void InputRouterImpl::Flush() {}
 
 bool InputRouterImpl::SendInput(scoped_ptr<IPC::Message> message) {
   DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
   switch (message->type()) {
@@ skipping 610 matching lines @@
             x, y, 0, event.latency));
       }
       break;
     case WebMouseEvent::ButtonNone:
       break;
   }
 }
 
 void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
   if (!touch_ack_timeout_supported_) {
-    touch_event_queue_->SetAckTimeoutEnabled(false, 0);
+    touch_event_queue_->SetAckTimeoutEnabled(false, base::TimeDelta());
     return;
   }
 
   // Mobile sites tend to be well-behaved with respect to touch handling, so
   // they have less need for the touch timeout fallback.
   const bool fixed_page_scale = (current_view_flags_ & FIXED_PAGE_SCALE) != 0;
   const bool mobile_viewport = (current_view_flags_ & MOBILE_VIEWPORT) != 0;
 
   // TOUCH_ACTION_NONE will prevent scrolling, in which case the timeout serves
   // little purpose. It's also a strong signal that touch handling is critical
   // to page functionality, so the timeout could do more harm than good.
   const bool touch_action_none =
       touch_action_filter_.allowed_touch_action() == TOUCH_ACTION_NONE;
 
   const bool touch_ack_timeout_enabled = !fixed_page_scale &&
                                          !mobile_viewport &&
                                          !touch_action_none;
   touch_event_queue_->SetAckTimeoutEnabled(touch_ack_timeout_enabled,
-                                           touch_ack_timeout_delay_ms_);
+                                           touch_ack_timeout_delay_);
 }
 
 bool InputRouterImpl::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content