Disable the touch ack timeout for touch-action:none

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 124 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),
-      touch_ack_timeout_enabled_(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_enabled_ =
+  touch_ack_timeout_supported_ =
       GetTouchAckTimeoutDelayMs(&touch_ack_timeout_delay_ms_);
-  touch_event_queue_->SetAckTimeoutEnabled(touch_ack_timeout_enabled_,
-                                           touch_ack_timeout_delay_ms_);
+  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()) {
     // Check for types that require an ACK.
@@ skipping 112 matching lines @@
       return;
     }
     mouse_move_pending_ = true;
   }
 
   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency, false);
 }
 
 void InputRouterImpl::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
-  if (WebTouchEventTraits::IsTouchSequenceStart(touch_event.event))
+  if (WebTouchEventTraits::IsTouchSequenceStart(touch_event.event)) {
     touch_action_filter_.ResetTouchAction();
+    // Note that if the previous touch-action was TOUCH_ACTION_NONE, enabling
+    // the timeout here will not take effect until the *following* touch
+    // sequence.  This is a desirable side-effect, giving the renderer a chance
+    // to send a touch-action response without racing against the ack timeout.
+    UpdateTouchAckTimeoutEnabled();
+  }
 
   FilterAndSendWebInputEvent(touch_event.event, touch_event.latency, false);
 }
 
 void InputRouterImpl::SendGestureEventImmediately(
     const GestureEventWithLatencyInfo& gesture_event) {
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 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.
   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_);
+  current_view_flags_ = view_flags;
+
+  // A fixed page scale or mobile viewport should disable the touch ack timeout.
+  UpdateTouchAckTimeoutEnabled();
 }
 
 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   bool message_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(InputRouterImpl, message, message_is_ok)
     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectRange_ACK, OnSelectRangeAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
                         OnSetTouchAction)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!message_is_ok)
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
 
   return handled;
 }
 
 void InputRouterImpl::OnTouchEventAck(const TouchEventWithLatencyInfo& event,
                                       InputEventAckState ack_result) {
   // Touchstart events sent to the renderer indicate a new touch sequence, but
   // in some cases we may filter out sending the touchstart - catch those here.
   if (WebTouchEventTraits::IsTouchSequenceStart(event.event) &&
       ack_result == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS) {
     touch_action_filter_.ResetTouchAction();
+    UpdateTouchAckTimeoutEnabled();
   }
   ack_handler_->OnTouchEventAck(event, ack_result);
 }
 
 void InputRouterImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   touch_event_queue_->OnGestureEventAck(event, ack_result);
   ProcessAckForOverscroll(event.event, ack_result);
   ack_handler_->OnGestureEventAck(event, ack_result);
@@ skipping 195 matching lines @@
 }
 
 void InputRouterImpl::OnHasTouchEventHandlers(bool has_handlers) {
   TRACE_EVENT1("input", "InputRouterImpl::OnHasTouchEventHandlers",
                "has_handlers", has_handlers);
 
   touch_event_queue_->OnHasTouchEventHandlers(has_handlers);
   client_->OnHasTouchEventHandlers(has_handlers);
 }
 
-void InputRouterImpl::OnSetTouchAction(
-    content::TouchAction touch_action) {
+void InputRouterImpl::OnSetTouchAction(TouchAction touch_action) {
   // Synthetic touchstart events should get filtered out in RenderWidget.
   DCHECK(touch_event_queue_->IsPendingAckTouchStart());
 
   touch_action_filter_.OnSetTouchAction(touch_action);
+
+  // TOUCH_ACTION_NONE should disable the touch ack timeout.
+  UpdateTouchAckTimeoutEnabled();
 }
 
 void InputRouterImpl::ProcessInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info,
     AckSource ack_source) {
   TRACE_EVENT2("input", "InputRouterImpl::ProcessInputEventAck",
                "type", WebInputEventTraits::GetName(event_type),
                "ack", GetEventAckName(ack_result));
@@ skipping 189 matching lines @@
         SendGestureEvent(MakeGestureEvent(
             WebInputEvent::GestureScrollEnd, mouse_event.timeStampSeconds,
             x, y, 0, event.latency));
       }
       break;
     case WebMouseEvent::ButtonNone:
       break;
   }
 }
 
+void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
+  if (!touch_ack_timeout_supported_) {
+    touch_event_queue_->SetAckTimeoutEnabled(false, 0);
+    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_);
+}
+
 bool InputRouterImpl::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content