Resend unconsumed scroll update from guest back to embedder (WebView Scroll Bubble).

content/browser/renderer_host/render_widget_host_impl.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_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 120 matching lines @@
     return host;
   }
 
  private:
   std::vector<RenderWidgetHostID> hosts_;
   size_t current_index_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostIteratorImpl);
 };
 
+inline blink::WebGestureEvent CreateScrollBeginForWrapping(
+    const blink::WebGestureEvent& gesture_event) {
+  DCHECK(gesture_event.type == blink::WebInputEvent::GestureScrollUpdate);
+
+  blink::WebGestureEvent wrap_gesture_scroll_begin;
+  wrap_gesture_scroll_begin.type = blink::WebInputEvent::GestureScrollBegin;
+  wrap_gesture_scroll_begin.data.scrollBegin.deltaXHint = 0;
+  wrap_gesture_scroll_begin.data.scrollBegin.deltaYHint = 0;
+  wrap_gesture_scroll_begin.resendingPluginId = gesture_event.resendingPluginId;
+
+  return wrap_gesture_scroll_begin;
+}
+
+inline blink::WebGestureEvent CreateScrollEndForWrapping(
+    const blink::WebGestureEvent& gesture_event) {
+  DCHECK(gesture_event.type == blink::WebInputEvent::GestureScrollUpdate);
+
+  blink::WebGestureEvent wrap_gesture_scroll_end;
+  wrap_gesture_scroll_end.type = blink::WebInputEvent::GestureScrollEnd;
+  wrap_gesture_scroll_end.resendingPluginId = gesture_event.resendingPluginId;
+
+  return wrap_gesture_scroll_end;
+}
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostImpl
 
 RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
                                            RenderProcessHost* process,
                                            int32_t routing_id,
                                            int32_t surface_id,
                                            bool hidden)
@@ skipping 19 matching lines @@
       in_flight_event_count_(0),
       in_get_backing_store_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(blink::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
+      is_in_gesture_scroll_(false),
       next_browser_snapshot_id_(1),
       owned_by_render_frame_host_(false),
       is_focused_(false),
       weak_factory_(this) {
   CHECK(delegate_);
   CHECK_NE(MSG_ROUTING_NONE, routing_id_);
   DCHECK_EQ(surface_id_, GpuSurfaceTracker::Get()->LookupSurfaceForRenderer(
                              process_->GetID(), routing_id_));
 
   std::pair<RoutingIDWidgetMap::iterator, bool> result =
@@ skipping 801 matching lines @@
 }
 
 void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo(
     const blink::WebGestureEvent& gesture_event,
     const ui::LatencyInfo& ui_latency) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardGestureEvent");
   // Early out if necessary, prior to performing latency logic.
   if (IgnoreInputEvents())
     return;
 
+  // TODO(wjmaclean) Remove the code for supporting resending gesture events
+  // when WebView transitions to OOPIF and BrowserPlugin is removed.
+  // http://crbug.com/533069
+  if (gesture_event.type == blink::WebInputEvent::GestureScrollBegin) {
+    DCHECK(!is_in_gesture_scroll_);
+    is_in_gesture_scroll_ = true;
+  } else if (gesture_event.type == blink::WebInputEvent::GestureScrollEnd ||
+             gesture_event.type == blink::WebInputEvent::GestureFlingStart) {
+    DCHECK(is_in_gesture_scroll_ ||
+           (gesture_event.type == blink::WebInputEvent::GestureFlingStart &&
+            gesture_event.sourceDevice ==
+                blink::WebGestureDevice::WebGestureDeviceTouchpad));
+    is_in_gesture_scroll_ = false;
+  }
+
+  bool scroll_update_needs_wrapping =
+      gesture_event.type == blink::WebInputEvent::GestureScrollUpdate &&
+      gesture_event.resendingPluginId != -1 && !is_in_gesture_scroll_;
+
+  if (scroll_update_needs_wrapping) {
+    ForwardGestureEventWithLatencyInfo(
+        CreateScrollBeginForWrapping(gesture_event), ui::LatencyInfo());
+  }
+
   if (delegate_->PreHandleGestureEvent(gesture_event))
     return;
 
   GestureEventWithLatencyInfo gesture_with_latency(gesture_event, ui_latency);
   latency_tracker_.OnInputEvent(gesture_event, &gesture_with_latency.latency);
   input_router_->SendGestureEvent(gesture_with_latency);
+
+  if (scroll_update_needs_wrapping) {
+    ForwardGestureEventWithLatencyInfo(
+        CreateScrollEndForWrapping(gesture_event), ui::LatencyInfo());
+  }
 }
 
 void RenderWidgetHostImpl::ForwardEmulatedTouchEvent(
       const blink::WebTouchEvent& touch_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardEmulatedTouchEvent");
 
   TouchEventWithLatencyInfo touch_with_latency(touch_event);
   latency_tracker_.OnInputEvent(touch_event, &touch_with_latency.latency);
   input_router_->SendTouchEvent(touch_with_latency);
 }
@@ skipping 1142 matching lines @@
 }
 
 #if defined(OS_WIN)
 gfx::NativeViewAccessible
     RenderWidgetHostImpl::GetParentNativeViewAccessible() {
   return delegate_ ? delegate_->GetParentNativeViewAccessible() : NULL;
 }
 #endif
 
 }  // namespace content