Initial browser-side implementation for touch-action

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 338 matching lines @@
       need_update_rect_for_auto_resize_(false),
       using_asynchronous_swapbuffers_(false),
       num_swapbuffers_complete_pending_(0),
       did_show_(false),
       is_hidden_(hidden),
       is_fullscreen_(false),
       needs_repainting_on_restore_(false),
       has_focus_(false),
       handling_input_event_(false),
       handling_ime_event_(false),
+      handling_touchstart_event_(false),
       closing_(false),
       is_swapped_out_(swapped_out),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       can_compose_inline_(true),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       suppress_next_char_events_(false),
       is_accelerated_compositing_active_(false),
@@ skipping 740 matching lines @@
   if (WebInputEvent::isGestureEventType(input_event->type)) {
     const WebGestureEvent& gesture_event =
         *static_cast<const WebGestureEvent*>(input_event);
     prevent_default = prevent_default || WillHandleGestureEvent(gesture_event);
   }
 
   if (input_event->type == WebInputEvent::GestureTap ||
       input_event->type == WebInputEvent::GestureLongPress)
     resetInputMethod();
 
+  if (input_event->type == WebInputEvent::TouchStart)
+      handling_touchstart_event_ = true;
+
   bool processed = prevent_default;
   if (input_event->type != WebInputEvent::Char || !suppress_next_char_events_) {
     suppress_next_char_events_ = false;
     if (!processed && webwidget_)
       processed = webwidget_->handleInputEvent(*input_event);
   }
 
+  handling_touchstart_event_ = false;
+
   // If this RawKeyDown event corresponds to a browser keyboard shortcut and
   // it's not processed by webkit, then we need to suppress the upcoming Char
   // events.
   if (!processed && is_keyboard_shortcut)
     suppress_next_char_events_ = true;
 
   InputEventAckState ack_result = processed ?
       INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
   if (!processed &&  input_event->type == WebInputEvent::TouchStart) {
     const WebTouchEvent& touch_event =
@@ skipping 1640 matching lines @@
 
 bool RenderWidget::WillHandleGestureEvent(
     const blink::WebGestureEvent& event) {
   return false;
 }
 
 void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
   Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
 }
 
+void RenderWidget::setTouchAction(
+    blink::WebTouchAction web_touch_action) {
+
+  // Ignore setTouchAction calls that result from synthetic touch events (eg.
+  // when blink is emulating touch with mouse).
+  if (!handling_touchstart_event_)
+    return;
+
+  content::TouchAction content_touch_action;
+  switch(web_touch_action) {
+    case blink::WebTouchActionNone:
+      content_touch_action = content::TOUCH_ACTION_NONE;
+      break;
+    case blink::WebTouchActionAuto:
+      content_touch_action = content::TOUCH_ACTION_AUTO;
+      break;
+    default:
+      NOTREACHED();

[piman, 2013/11/21 05:16:27]

nit: remove default case to get a compile-time warning instead of a run-time
one, if the enum changes.

[Rick Byers, 2013/11/21 22:34:05]

That would make it extremely painful to extend the blink API.  My next step is
to add some more values to the enum.  If we compile-time-asserted in chromium
then we'd have no way to add values to the definition in blink (other than
create a new enum and APIs that use it and migrate over).  I can avoid actually
sending the new values at runtime though until the chromium side has been
updated to use them.

Sigh - can't wait until blink and chromium are in the same tree ;-)

+  }
+  Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
+}
+
 bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
   return true;
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 RenderWidget::CreateGraphicsContext3D(
     const blink::WebGraphicsContext3D::Attributes& attributes) {
   if (!webwidget_)
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 46 matching lines @@
           GetURLForGraphicsContext3D(),
           gpu_channel_host.get(),
           use_echo_for_swap_ack,
           attributes,
           false /* bind generates resources */,
           limits));
   return context.Pass();
 }
 
 }  // namespace content