Initial browser-side implementation for touch-action

content/browser/renderer_host/input/immediate_input_router.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/immediate_input_router.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/edit_command.h"
 #include "content/common/input/web_input_event_traits.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/common/input_event_ack_state.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/touch_action.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
@@ skipping 137 matching lines @@
   HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
   gesture_event_filter_->FlingHasBeenHalted();
 
   // Only forward the non-native portions of our event.
   FilterAndSendWebInputEvent(key_event, latency_info, is_keyboard_shortcut);
 }
 
 void ImmediateInputRouter::SendGestureEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
+  if (touch_action_filter_.FilterGestureEvent(gesture_event.event))
+    return;
+
   HandleGestureScroll(gesture_event);
 
   if (!IsInOverscrollGesture() &&
       !gesture_event_filter_->ShouldForward(gesture_event)) {
     OverscrollController* controller = client_->GetOverscrollController();
     if (controller)
       controller->DiscardingGestureEvent(gesture_event.event);
     return;
   }
 
@@ skipping 27 matching lines @@
   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency, false);
 }
 
 void ImmediateInputRouter::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
   FilterAndSendWebInputEvent(touch_event.event, touch_event.latency, false);
 }
 
 void ImmediateInputRouter::SendGestureEventImmediately(
     const GestureEventWithLatencyInfo& gesture_event) {
+  if (touch_action_filter_.FilterGestureEvent(gesture_event.event))

[jdduke (slow), 2013/11/18 15:56:00]

Hmm, do you know why |HandleGestureScroll()| is in both |SendGestureEvent()| and
|SendGestureEventImmediately()|?  It apears  we're doing some double bookkeeping
here that could be somewhat racy, and I wonder if the same might be happening
with |touch_action_filter_|... ideally the filter would be called but once per
gesture event?

[Rick Byers, 2013/11/19 22:14:59]

Ah, I was thinking a gesture event could come in by either path - I forgot that
ForwardGestureEventImmediately should only have events that have already gone
through ForwardGestureEvent.

Perhaps the HandleGestureScroll was making the same mistake.  miletus@ you added
this, right?  Can you look into this?

Anyway fixed the touch action case here.

+    return;
   HandleGestureScroll(gesture_event);
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 const NativeWebKeyboardEvent*
     ImmediateInputRouter::GetLastKeyboardEvent() const {
   if (key_queue_.empty())
     return NULL;
   return &key_queue_.front();
 }
 
 bool ImmediateInputRouter::ShouldForwardTouchEvent() const {
   // Always send a touch event if the renderer has a touch-event handler. It is
   // possible that a renderer stops listening to touch-events while there are
   // still events in the touch-queue. In such cases, the new events should still
   // get into the queue.
   return has_touch_handler_ || !touch_event_queue_->empty();
 }
 
 bool ImmediateInputRouter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   bool message_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(ImmediateInputRouter, 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(ViewHostMsg_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 ImmediateInputRouter::OnTouchEventAck(
@@ skipping 199 matching lines @@
 
 void ImmediateInputRouter::OnHasTouchEventHandlers(bool has_handlers) {
  if (has_touch_handler_ == has_handlers)
     return;
   has_touch_handler_ = has_handlers;
   if (!has_handlers)
     touch_event_queue_->FlushQueue();
   client_->OnHasTouchEventHandlers(has_handlers);
 }
 
+void ImmediateInputRouter::OnSetTouchAction(
+    int touch_id,
+    content::TouchAction touchAction)

[jdduke (slow), 2013/11/18 15:56:00]

Nit: Brace on same line as closing paren.

[sadrul, 2013/11/19 10:36:44]

touch_action

[Rick Byers, 2013/11/19 22:14:59]

Done.

[Rick Byers, 2013/11/19 22:14:59]

Done.

+{
+  // Don't process touch-action messages for synthetic touches we know
+  // nothing about.
+  if (touch_event_queue_->IsPendingAckTouchStart(touch_id))
+    touch_action_filter_.OnSetTouchAction(touch_id, touchAction);
+}
+
 void ImmediateInputRouter::ProcessInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info,
     AckSource ack_source) {
   TRACE_EVENT2("input", "ImmediateInputRouter::ProcessInputEventAck",
                "type", WebInputEventTraits::GetName(event_type),
                "ack", GetEventAckName(ack_result));
 
   // Note: The keyboard ack must be treated carefully, as it may result in
@@ skipping 200 matching lines @@
       break;
   }
 }
 
 bool ImmediateInputRouter::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content