Route touch-events for WebViewGuest directly to guest renderer.

content/browser/frame_host/render_widget_host_view_guest.cc

 // Copyright 2014 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 "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_delegate.h"
+#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/common/view_messages.h"
 #include "content/common/webplugin_geometry.h"
 #include "content/public/common/content_switches.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 
@@ skipping 22 matching lines @@
 }  // namespace
 
 RenderWidgetHostViewGuest::RenderWidgetHostViewGuest(
     RenderWidgetHost* widget_host,
     BrowserPluginGuest* guest,
     base::WeakPtr<RenderWidgetHostViewBase> platform_view)
     : RenderWidgetHostViewChildFrame(widget_host),
       // |guest| is NULL during test.
       guest_(guest ? guest->AsWeakPtr() : base::WeakPtr<BrowserPluginGuest>()),
       platform_view_(platform_view) {
-#if defined(USE_AURA)
-  gesture_recognizer_.reset(ui::GestureRecognizer::Create());
-  gesture_recognizer_->AddGestureEventHelper(this);
-#endif  // defined(USE_AURA)
 }
 
 RenderWidgetHostViewGuest::~RenderWidgetHostViewGuest() {
-#if defined(USE_AURA)
-  gesture_recognizer_->RemoveGestureEventHelper(this);
-#endif  // defined(USE_AURA)
 }
 
 bool RenderWidgetHostViewGuest::OnMessageReceivedFromEmbedder(
     const IPC::Message& message,
     RenderWidgetHostImpl* embedder) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(RenderWidgetHostViewGuest, message,
                                    embedder)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_HandleInputEvent,
                         OnHandleInputEvent)
@@ skipping 47 matching lines @@
 
 bool RenderWidgetHostViewGuest::HasFocus() const {
   if (!guest_)
     return false;
   return guest_->focused();
 }
 
 #if defined(USE_AURA)
 void RenderWidgetHostViewGuest::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
-  // TODO(fsamuel): Currently we will only take this codepath if the guest has
-  // requested touch events. A better solution is to always forward touchpresses
-  // to the embedder process to target a BrowserPlugin, and then route all
-  // subsequent touch points of that touchdown to the appropriate guest until
-  // that touch point is released.
-  ScopedVector<ui::TouchEvent> events;
-  if (!MakeUITouchEventsFromWebTouchEvents(touch, &events, LOCAL_COORDINATES))
-    return;
+  TouchEventWithLatencyInfo touch_in_guest_coords(touch.event,
+                                                     touch.latency);

[tdresser, 2015/11/02 15:38:24]

Indentation.

[wjmaclean, 2015/11/02 19:23:10]

Done.

+  // Convert coordinates to something suitable for the embedder.

[tdresser, 2015/11/02 15:38:24]

Do we ever actually use these co-ordinates? I seem to remember that I was to
switch from passing a touch event to just passing the type and unique event id.

It might be worth making that change - or at least double checking that this
logic is necessary.

[wjmaclean, 2015/11/02 19:23:10]

Hmmm, it looks like we're *not* using the coords, just the IDs. I think we used
to use the coords, but that was when they went to the local GR, and it would
have been expecting everything in coords local to the guest. I'll remove this.

[tdresser, 2015/11/02 21:10:19]

Can you file a bug to stop passing the full event here, and reference it in a
comment?

Feel free to assign it to me.

+  for (unsigned i = 0; i < touch_in_guest_coords.event.touchesLength; ++i) {
+    blink::WebTouchPoint& touch_point = touch_in_guest_coords.event.touches[i];
+    gfx::PointF guest_point(touch_point.position.x, touch_point.position.y);
+    gfx::PointF converted_point = guest_->GetScreenCoordinates(guest_point);
+    touch_point.position.x = converted_point.x();
+    touch_point.position.y = converted_point.y();
+  }
 
-  ui::EventResult result = (ack_result ==
-      INPUT_EVENT_ACK_STATE_CONSUMED) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
-  for (ScopedVector<ui::TouchEvent>::iterator iter = events.begin(),
-      end = events.end(); iter != end; ++iter)  {
-    if (!gesture_recognizer_->ProcessTouchEventPreDispatch(*iter, this))
-      continue;
-
-    scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-    gestures.reset(gesture_recognizer_->AckTouchEvent(
-        (*iter)->unique_event_id(), result, this));
-    ProcessGestures(gestures.get());
-  }
+  GetOwnerRenderWidgetHostView()->ProcessAckedTouchEvent(touch_in_guest_coords,
+                                                         ack_result);
 }
 #endif
 
+void RenderWidgetHostViewGuest::ProcessTouchEvent(
+    const blink::WebTouchEvent& event,
+    const ui::LatencyInfo& latency) {

[tdresser, 2015/11/02 15:38:24]

Maybe 
GetOwnerRenderWidgetHostView()->ProcessTouchEvent(...)
for symmetry with the above?

[wjmaclean, 2015/11/02 19:23:10]

This is more analogous to RenderWidgetHostViewChildFrame::ProcessMouseEvent() I
think. In the code above, the events are flowing up (being acked), not down as
they are here.

[tdresser, 2015/11/02 21:10:19]

SGTM.

+  host_->ForwardTouchEventWithLatencyInfo(event, latency);
+}
+
 gfx::Rect RenderWidgetHostViewGuest::GetViewBounds() const {
   if (!guest_)
     return gfx::Rect();
 
   RenderWidgetHostViewBase* rwhv = GetOwnerRenderWidgetHostView();
   gfx::Rect embedder_bounds;
   if (rwhv)
     embedder_bounds = rwhv->GetViewBounds();
   return gfx::Rect(
       guest_->GetScreenCoordinates(embedder_bounds.origin()), size_);
@@ skipping 47 matching lines @@
   // When not using surfaces, the frame just gets proxied to
   // the embedder's renderer to be composited.
   if (!frame->delegated_frame_data || !use_surfaces_) {
     guest_->SwapCompositorFrame(output_surface_id,
                                 host_->GetProcess()->GetID(),
                                 host_->GetRoutingID(),
                                 frame.Pass());
     return;
   }
 
+  if (!has_started_rendering_) {
+    if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
+      host_->delegate()->GetInputEventRouter()->AddSurfaceIdNamespaceOwner(
+          GetSurfaceIdNamespace(), this);
+    }
+    has_started_rendering_ = true;
+  }
+
   cc::RenderPass* root_pass =
       frame->delegated_frame_data->render_pass_list.back();
 
   gfx::Size frame_size = root_pass->output_rect.size();
   float scale_factor = frame->metadata.device_scale_factor;
 
   // Check whether we need to recreate the cc::Surface, which means the child
   // frame renderer has changed its output surface, or size, or scale factor.
   if (output_surface_id != last_output_surface_id_ && surface_factory_) {
     surface_factory_->Destroy(surface_id_);
@@ skipping 480 matching lines @@
     if (gesture_event.type == blink::WebInputEvent::GestureScrollUpdate &&
         gesture_event.data.scrollUpdate.inertial) {
       return;
     }
     host_->ForwardGestureEvent(gesture_event);
     return;
   }
 }
 
 }  // namespace content