Route touch-events for WebViewGuest directly to guest renderer.

content/browser/renderer_host/render_widget_host_view_aura.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <set>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 27 matching lines @@
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.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_impl.h"
 #include "content/browser/renderer_host/render_widget_host_input_event_router.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/common/site_isolation_policy.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ skipping 792 matching lines @@
                                   ui::EF_RIGHT_MOUSE_BUTTON;
       return (event->flags() & kAllowedButtons) != 0;
     }
     default:
       break;
   }
 #endif
   return true;
 }
 
+bool RenderWidgetHostViewAura::ShouldRouteEvent(const ui::Event* event) const {
+  // We should route an event in two cases:
+  // 1) If cross-process frames are possible, then we route the event.

[Charlie Reis, 2015/12/10 21:58:14]

This doesn't seem to be what the code below is doing.  The comment makes it
sound like "cross-process frames are possible" implies "route the event."  The
code below doesn't seem to take AreCrossProcessFramesPossible into account
unless |result| is true, in which case *both* |result| and
AreCrossProcessFramesPossible need to be true.

[wjmaclean, 2015/12/10 22:44:14]

Perhaps I've badly worded the comment. Prior to this CL we only checked if the
IER exists, as that is gated on AreCrossProcessFramesPossible. It also only
handled mouse/wheel events.

This CL changes it so the IER is always created, but we still don't route
mouse/wheel events if AreCrossProcessFramesPossible is false. But we do always
route touch events.

+  // 2) Even if (1) is not satisfied, we still route the event if we have
+  //    an input event router: at present this only happens for touch events,
+  //    and is required in order that pinch-zoom works properly for
+  //    WebViews.
+  bool result = host_->delegate() && host_->delegate()->GetInputEventRouter();

[Charlie Reis, 2015/12/10 21:58:15]

This looks like it will almost always be true (unless the tab is being
destroyed), due to the change to WebContents.

[wjmaclean, 2015/12/10 22:44:14]

Yes. But |result| can be set false if we are dealing with a mouse/wheel event,
and --site-per-process isn't on.

+  if (event->IsMouseEvent())
+    result = result && SiteIsolationPolicy::AreCrossProcessFramesPossible();

[Charlie Reis, 2015/12/10 21:58:15]

On a related note, we should confirm whether AreCrossProcessFramesPossible is
the right thing to be checking here.

In the near future, we'll likely be turning on --isolate-extensions by default,
which means AreCrossProcessFramesPossible will always return true (since there
will be OOPIFs for web iframes inside extensions).  --site-per-process mode is
still further out.

Is that what you'd expect?  Are there blocking issues here before we turn that
on by default?

[wjmaclean, 2015/12/10 22:44:14]

OK. This code is based on the existing logic, so if it's wrong in this CL, then
I suspect it's also wrong in the existing code.
I certainly wouldn't expect the IER to be enable for all RWHVA's with just
--isolate-extensions, so perhaps AreCrossProcessFramesPossible is wrong, but
then (as mentioned above) I think it's also wrong for the existing logic.

+  return result;
+}
+
 void RenderWidgetHostViewAura::HandleParentBoundsChanged() {
   SnapToPhysicalPixelBoundary();
 #if defined(OS_WIN)
   if (legacy_render_widget_host_HWND_) {
     legacy_render_widget_host_HWND_->SetBounds(
         window_->GetBoundsInRootWindow());
   }
 #endif
   if (!in_shutdown_)
     host_->SendScreenRects();
@@ skipping 1250 matching lines @@
                         reinterpret_cast<LPARAM>(toplevel_hwnd));
     }
 #endif
     // The Disambiguation popup does not parent itself from this window, so we
     // manually dismiss it.
     HideDisambiguationPopup();
 
     blink::WebMouseWheelEvent mouse_wheel_event =
         MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent&>(*event));
     if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0) {
-      if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
+      if (ShouldRouteEvent(event)) {
         host_->delegate()->GetInputEventRouter()->RouteMouseWheelEvent(
             this, &mouse_wheel_event);
       } else {
         ProcessMouseWheelEvent(mouse_wheel_event);
       }
     }
   } else {
     bool is_selection_popup =
         popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab();
     if (CanRendererHandleEvent(event, mouse_locked_, is_selection_popup) &&
         !(event->flags() & ui::EF_FROM_TOUCH)) {
       // Confirm existing composition text on mouse press, to make sure
       // the input caret won't be moved with an ongoing composition text.
       if (event->type() == ui::ET_MOUSE_PRESSED)
         FinishImeCompositionSession();
 
       blink::WebMouseEvent mouse_event = MakeWebMouseEvent(*event);
       ModifyEventMovementAndCoords(&mouse_event);
-      if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
+      if (ShouldRouteEvent(event)) {
         host_->delegate()->GetInputEventRouter()->RouteMouseEvent(this,
                                                                   &mouse_event);
       } else {
         ProcessMouseEvent(mouse_event);
       }
 
       // Ensure that we get keyboard focus on mouse down as a plugin window may
       // have grabbed keyboard focus.
       if (event->type() == ui::ET_MOUSE_PRESSED)
         SetKeyboardFocus();
@@ skipping 52 matching lines @@
 void RenderWidgetHostViewAura::ProcessMouseEvent(
     const blink::WebMouseEvent& event) {
   host_->ForwardMouseEvent(event);
 }
 
 void RenderWidgetHostViewAura::ProcessMouseWheelEvent(
     const blink::WebMouseWheelEvent& event) {
   host_->ForwardWheelEvent(event);
 }
 
+void RenderWidgetHostViewAura::ProcessTouchEvent(
+    const blink::WebTouchEvent& event,
+    const ui::LatencyInfo& latency) {
+  host_->ForwardTouchEventWithLatencyInfo(event, latency);
+}
+
 void RenderWidgetHostViewAura::TransformPointToLocalCoordSpace(
     const gfx::Point& point,
     cc::SurfaceId original_surface,
     gfx::Point* transformed_point) {
   delegated_frame_host_->TransformPointToLocalCoordSpace(
       point, original_surface, transformed_point);
 }
 
 void RenderWidgetHostViewAura::OnScrollEvent(ui::ScrollEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnScrollEvent");
@@ skipping 54 matching lines @@
 
   // It is important to always mark events as being handled asynchronously when
   // they are forwarded. This ensures that the current event does not get
   // processed by the gesture recognizer before events currently awaiting
   // dispatch in the touch queue.
   event->DisableSynchronousHandling();
 
   // Set unchanged touch point to StateStationary for touchmove and
   // touchcancel to make sure only send one ack per WebTouchEvent.
   MarkUnchangedTouchPointsAsStationary(&touch_event, event->touch_id());
-  host_->ForwardTouchEventWithLatencyInfo(touch_event, *event->latency());
+  if (ShouldRouteEvent(event)) {
+    host_->delegate()->GetInputEventRouter()->RouteTouchEvent(
+        this, &touch_event, *event->latency());
+  } else {
+    ProcessTouchEvent(touch_event, *event->latency());
+  }
 }
 
 void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnGestureEvent");
 
   if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       event->type() == ui::ET_GESTURE_PINCH_END) && !pinch_zoom_enabled_) {
     event->SetHandled();
     return;
@@ skipping 683 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content