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 19 matching lines @@
 }
 #endif  // defined(USE_AURA)
 
 }  // namespace
 
 RenderWidgetHostViewGuest::RenderWidgetHostViewGuest(
     RenderWidgetHost* widget_host,
     BrowserPluginGuest* guest,
     base::WeakPtr<RenderWidgetHostViewBase> platform_view)
     : RenderWidgetHostViewChildFrame(widget_host),
+      has_started_rendering_(false),
       // |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;
-
-  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());
-  }
+  // TODO(TDRESSER): Since all ProcessAckedTouchEvent() uses is the event id,
+  // don't pass the full event object here. https://crbug.com/550581.
+  GetOwnerRenderWidgetHostView()->ProcessAckedTouchEvent(touch, ack_result);
 }
 #endif
 
+void RenderWidgetHostViewGuest::ProcessTouchEvent(
+    const blink::WebTouchEvent& event,
+    const ui::LatencyInfo& latency) {
+  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_) {

[Fady Samuel, 2015/11/05 18:09:11]

drive-by: This doesn't seem right. A guest can be attached and detached multiple
times during its lifetime. In fact, every time you set display:none, the guest
is detached, and then display:block will reattach it to a new BrowserPlugin.

This is not a good signal for attachment.

+    // We need to register again now that we've started rendering, since when
+    // we originally registered our WebContents may not have been attached
+    // to the OuterWebContents.
+    if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
+      RenderWidgetHostInputEventRouter* event_router =
+          host_->delegate()->GetInputEventRouter();
+      if (!event_router->is_registered(GetSurfaceIdNamespace()))
+        event_router->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 307 matching lines @@
   return NULL;
 }
 #endif
 
 void RenderWidgetHostViewGuest::DestroyGuestView() {
   host_->SetView(NULL);
   host_ = NULL;
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-bool RenderWidgetHostViewGuest::CanDispatchToConsumer(
-    ui::GestureConsumer* consumer) {
-  CHECK_EQ(static_cast<RenderWidgetHostViewGuest*>(consumer), this);
-  return true;
-}
-
-void RenderWidgetHostViewGuest::DispatchGestureEvent(
-    ui::GestureEvent* event) {
-  ForwardGestureEventToRenderer(event);
-}
-
-void RenderWidgetHostViewGuest::DispatchCancelTouchEvent(
-    ui::TouchEvent* event) {
-  if (!host_)
-    return;
-
-  blink::WebTouchEvent cancel_event;
-  // TODO(rbyers): This event has no touches in it.  Don't we need to know what
-  // touches are currently active in order to cancel them all properly?
-  WebTouchEventTraits::ResetType(blink::WebInputEvent::TouchCancel,
-                                 event->time_stamp().InSecondsF(),
-                                 &cancel_event);
-
-  host_->ForwardTouchEventWithLatencyInfo(cancel_event, *event->latency());
-}
-
 bool RenderWidgetHostViewGuest::ForwardGestureEventToRenderer(
     ui::GestureEvent* gesture) {
 #if defined(USE_AURA)
   if (!host_)
     return false;
 
   if ((gesture->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       gesture->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       gesture->type() == ui::ET_GESTURE_PINCH_END) && !pinch_zoom_enabled_) {
     return true;
@@ skipping 127 matching lines @@
     if (gesture_event.type == blink::WebInputEvent::GestureScrollUpdate &&
         gesture_event.data.scrollUpdate.inertial) {
       return;
     }
     host_->ForwardGestureEvent(gesture_event);
     return;
   }
 }
 
 }  // namespace content