Browser Plugin: Added gesture recognizer per guest RenderView.

Each BrowserPlugin gets its own gesture recognizer in RenderWidgetHostViewGuest.

BUG=181313

Review URL: https://chromiumcodereview.appspot.com/12792012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@190173 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 168 insertions, 10 deletions

diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 2e017cc..4b02fda 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -773,7 +773,7 @@ void RenderWidgetHostImpl::ScheduleComposite() {
 }
 
 void RenderWidgetHostImpl::StartHangMonitorTimeout(TimeDelta delay) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
+  if (!GetProcess()->IsGuest() && CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     return;
   }
diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
index 479530a..e81bc5d 100644
--- a/content/browser/renderer_host/render_widget_host_impl.h
+++ b/content/browser/renderer_host/render_widget_host_impl.h
@@ -93,6 +93,10 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
   // uses RenderWidgetHost::AsRenderWidgetHostImpl().
   static RenderWidgetHostImpl* From(RenderWidgetHost* rwh);
 
+  void set_hung_renderer_delay_ms(const base::TimeDelta& timeout) {
+    hung_renderer_delay_ms_ = timeout.InMilliseconds();
+  }
+
   // RenderWidgetHost implementation.
   virtual void Undo() OVERRIDE;
   virtual void Redo() OVERRIDE;
diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index c6cbb7b..54e5472 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc
@@ -2941,13 +2941,18 @@ TEST_F(RenderWidgetHostTest, AckedTouchEventState) {
                                  WebInputEvent::TouchStart,
                                  WebInputEvent::TouchMove };
 
+  TouchEventCoordinateSystem coordinate_system =  LOCAL_COORDINATES;
+#if !defined(OS_WIN)
+  coordinate_system = SCREEN_COORDINATES;
+#endif
   for (size_t i = 0; i < arraysize(acks); ++i) {
     SendInputEventACK(acks[i],
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
     EXPECT_EQ(acks[i], view_->acked_event().type);
     ScopedVector<ui::TouchEvent> acked;
 
-    MakeUITouchEventsFromWebTouchEvents(view_->acked_event(), &acked);
+    MakeUITouchEventsFromWebTouchEvents(
+        view_->acked_event(), &acked, coordinate_system);
     bool success = EventListIsSubset(acked, expected_events);
     EXPECT_TRUE(success) << "Failed on step: " << i;
     if (!success)
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index 5faf559..c7d3aff 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -1597,7 +1597,8 @@ gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
 void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
     const WebKit::WebTouchEvent& touch_event, InputEventAckState ack_result) {
   ScopedVector<ui::TouchEvent> events;
-  if (!MakeUITouchEventsFromWebTouchEvents(touch_event, &events))
+  if (!MakeUITouchEventsFromWebTouchEvents(touch_event, &events,
+                                           SCREEN_COORDINATES))
     return;
 
   aura::RootWindow* root = window_->GetRootWindow();
diff --git a/content/browser/renderer_host/render_widget_host_view_guest.cc b/content/browser/renderer_host/render_widget_host_view_guest.cc
index b2ea113..5e414cb 100644
--- a/content/browser/renderer_host/render_widget_host_view_guest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_guest.cc
@@ -9,6 +9,9 @@
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_guest.h"
+#if defined(OS_WIN) || defined(USE_AURA)
+#include "content/browser/renderer_host/ui_events_helper.h"
+#endif
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
@@ -19,6 +22,24 @@
 
 namespace content {
 
+namespace {
+
+bool ShouldSendPinchGesture() {
+  static bool pinch_allowed =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePinch);
+  return pinch_allowed;
+}
+
+WebKit::WebGestureEvent CreateFlingCancelEvent(double time_stamp) {
+  WebKit::WebGestureEvent gesture_event;
+  gesture_event.timeStampSeconds = time_stamp;
+  gesture_event.type = WebKit::WebGestureEvent::GestureFlingCancel;
+  gesture_event.sourceDevice = WebKit::WebGestureEvent::Touchscreen;
+  return gesture_event;
+}
+
+}  // namespace
+
 RenderWidgetHostViewGuest::RenderWidgetHostViewGuest(
     RenderWidgetHost* widget_host,
     BrowserPluginGuest* guest,
@@ -27,6 +48,9 @@ RenderWidgetHostViewGuest::RenderWidgetHostViewGuest(
       guest_(guest),
       is_hidden_(false),
       platform_view_(static_cast<RenderWidgetHostViewPort*>(platform_view)) {
+#if defined(OS_WIN) || defined(USE_AURA)
+  gesture_recognizer_.reset(ui::GestureRecognizer::Create(this));
+#endif  // defined(OS_WIN) || defined(USE_AURA)
   host_->SetView(this);
 }
 
@@ -63,6 +87,30 @@ gfx::GLSurfaceHandle RenderWidgetHostViewGuest::GetCompositingSurface() {
   return gfx::GLSurfaceHandle(gfx::kNullPluginWindow, gfx::TEXTURE_TRANSPORT);
 }
 
+#if defined(OS_WIN) || defined(USE_AURA)
+void RenderWidgetHostViewGuest::ProcessAckedTouchEvent(
+    const WebKit::WebTouchEvent& 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)  {
+    scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
+    gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
+        *(*iter), result, this));
+    ProcessGestures(gestures.get());
+  }
+}
+#endif
+
 void RenderWidgetHostViewGuest::Show() {
   WasShown();
 }
@@ -383,4 +431,71 @@ void RenderWidgetHostViewGuest::DestroyGuestView() {
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
+bool RenderWidgetHostViewGuest::DispatchLongPressGestureEvent(
+    ui::GestureEvent* event) {
+  return ForwardGestureEventToRenderer(event);
+}
+
+bool RenderWidgetHostViewGuest::DispatchCancelTouchEvent(
+    ui::TouchEvent* event) {
+  if (!host_)
+    return false;
+
+  WebKit::WebTouchEvent cancel_event;
+  cancel_event.type = WebKit::WebInputEvent::TouchCancel;
+  cancel_event.timeStampSeconds = event->time_stamp().InSecondsF();
+  host_->ForwardTouchEvent(cancel_event);
+  return true;
+}
+
+bool RenderWidgetHostViewGuest::ForwardGestureEventToRenderer(
+    ui::GestureEvent* gesture) {
+#if defined(OS_WIN) || defined(USE_AURA)
+  if (!host_)
+    return false;
+
+  // Pinch gestures are disabled by default on windows desktop. See
+  // crbug.com/128477 and crbug.com/148816
+  if ((gesture->type() == ui::ET_GESTURE_PINCH_BEGIN ||
+      gesture->type() == ui::ET_GESTURE_PINCH_UPDATE ||
+      gesture->type() == ui::ET_GESTURE_PINCH_END) &&
+      !ShouldSendPinchGesture()) {
+    return true;
+  }
+
+  WebKit::WebGestureEvent web_gesture =
+      MakeWebGestureEventFromUIEvent(*gesture);
+  const gfx::Point& client_point = gesture->location();
+  const gfx::Point& screen_point = gesture->location();
+
+  web_gesture.x = client_point.x();
+  web_gesture.y = client_point.y();
+  web_gesture.globalX = screen_point.x();
+  web_gesture.globalY = screen_point.y();
+
+  if (web_gesture.type == WebKit::WebGestureEvent::Undefined)
+    return false;
+  if (web_gesture.type == WebKit::WebGestureEvent::GestureTapDown) {
+    host_->ForwardGestureEvent(
+        CreateFlingCancelEvent(gesture->time_stamp().InSecondsF()));
+  }
+  host_->ForwardGestureEvent(web_gesture);
+  return true;
+#else
+  return false;
+#endif
+}
+
+void RenderWidgetHostViewGuest::ProcessGestures(
+    ui::GestureRecognizer::Gestures* gestures) {
+  if ((gestures == NULL) || gestures->empty())
+    return;
+  for (ui::GestureRecognizer::Gestures::iterator g_it = gestures->begin();
+      g_it != gestures->end();
+      ++g_it) {
+    ForwardGestureEventToRenderer(*g_it);
+  }
+}
+
+
 }  // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_guest.h b/content/browser/renderer_host/render_widget_host_view_guest.h
index f26ed5f..a0949a7 100644
--- a/content/browser/renderer_host/render_widget_host_view_guest.h
+++ b/content/browser/renderer_host/render_widget_host_view_guest.h
@@ -10,6 +10,9 @@
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/content_export.h"
+#include "ui/base/events/event.h"
+#include "ui/base/gestures/gesture_recognizer.h"
+#include "ui/base/gestures/gesture_types.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d_f.h"
@@ -34,7 +37,9 @@ struct NativeWebKeyboardEvent;
 // the relevant calls to the platform view.
 // -----------------------------------------------------------------------------
 class CONTENT_EXPORT RenderWidgetHostViewGuest
-    : public RenderWidgetHostViewBase {
+    : public RenderWidgetHostViewBase,
+      public ui::GestureConsumer,
+      public ui::GestureEventHelper {
  public:
   RenderWidgetHostViewGuest(RenderWidgetHost* widget,
                             BrowserPluginGuest* guest,
@@ -123,6 +128,10 @@ class CONTENT_EXPORT RenderWidgetHostViewGuest
       bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE;
   virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE;
   virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE;
+#if defined(OS_WIN) || defined(USE_AURA)
+  virtual void ProcessAckedTouchEvent(const WebKit::WebTouchEvent& touch,
+                                      InputEventAckState ack_result) OVERRIDE;
+#endif  // defined(OS_WIN) || defined(USE_AURA)
   virtual bool LockMouse() OVERRIDE;
   virtual void UnlockMouse() OVERRIDE;
   virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE;
@@ -171,6 +180,10 @@ class CONTENT_EXPORT RenderWidgetHostViewGuest
   virtual void WillWmDestroy() OVERRIDE;
 #endif  // defined(OS_WIN) && !defined(USE_AURA)
 
+  // Overridden from ui::GestureEventHelper.
+  virtual bool DispatchLongPressGestureEvent(ui::GestureEvent* event) OVERRIDE;
+  virtual bool DispatchCancelTouchEvent(ui::TouchEvent* event) OVERRIDE;
+
  protected:
   friend class RenderWidgetHostView;
 
@@ -178,6 +191,12 @@ class CONTENT_EXPORT RenderWidgetHostViewGuest
   // Destroys this view without calling |Destroy| on |platform_view_|.
   void DestroyGuestView();
 
+  // Builds and forwards a WebKitGestureEvent to the renderer.
+  bool ForwardGestureEventToRenderer(ui::GestureEvent* gesture);
+
+  // Process all of the given gestures (passes them on to renderer)
+  void ProcessGestures(ui::GestureRecognizer::Gestures* gestures);
+
   // The model object.
   RenderWidgetHostImpl* host_;
 
@@ -187,7 +206,9 @@ class CONTENT_EXPORT RenderWidgetHostViewGuest
   // RenderWidgetHostViewGuest mostly only cares about stuff related to
   // compositing, the rest are directly forwared to this |platform_view_|.
   RenderWidgetHostViewPort* platform_view_;
-
+#if defined(OS_WIN) || defined(USE_AURA)
+  scoped_ptr<ui::GestureRecognizer> gesture_recognizer_;
+#endif  // defined(OS_WIN) || defined(USE_AURA)
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewGuest);
 };
 
diff --git a/content/browser/renderer_host/render_widget_host_view_win.cc b/content/browser/renderer_host/render_widget_host_view_win.cc
index e4fd2ec..ec15a1a 100644
--- a/content/browser/renderer_host/render_widget_host_view_win.cc
+++ b/content/browser/renderer_host/render_widget_host_view_win.cc
@@ -888,7 +888,7 @@ void RenderWidgetHostViewWin::ProcessAckedTouchEvent(
   DCHECK(touch_events_enabled_);
 
   ScopedVector<ui::TouchEvent> events;
-  if (!MakeUITouchEventsFromWebTouchEvents(touch, &events))
+  if (!MakeUITouchEventsFromWebTouchEvents(touch, &events, LOCAL_COORDINATES))
     return;
 
   ui::EventResult result = (ack_result ==
diff --git a/content/browser/renderer_host/ui_events_helper.cc b/content/browser/renderer_host/ui_events_helper.cc
index 889b1e5..fedb641 100644
--- a/content/browser/renderer_host/ui_events_helper.cc
+++ b/content/browser/renderer_host/ui_events_helper.cc
@@ -89,8 +89,10 @@ WebKit::WebInputEvent::Type TouchEventTypeFromEvent(
 
 namespace content {
 
-bool MakeUITouchEventsFromWebTouchEvents(const WebKit::WebTouchEvent& touch,
-                                         ScopedVector<ui::TouchEvent>* list) {
+bool MakeUITouchEventsFromWebTouchEvents(
+    const WebKit::WebTouchEvent& touch,
+    ScopedVector<ui::TouchEvent>* list,
+    TouchEventCoordinateSystem coordinate_system) {
   ui::EventType type = ui::ET_UNKNOWN;
   switch (touch.type) {
     case WebKit::WebInputEvent::TouchStart:
@@ -122,7 +124,11 @@ bool MakeUITouchEventsFromWebTouchEvents(const WebKit::WebTouchEvent& touch,
     // the touch-event is dispatched directly to the gesture-recognizer, so the
     // location needs to be in the local coordinate space.
 #if defined(USE_AURA)
-    gfx::Point location(point.screenPosition.x, point.screenPosition.y);
+    gfx::Point location;
+    if (coordinate_system == LOCAL_COORDINATES)
+      location = gfx::Point(point.position.x, point.position.y);
+    else
+      location = gfx::Point(point.screenPosition.x, point.screenPosition.y);
 #else
     gfx::Point location(point.position.x, point.position.y);
 #endif
diff --git a/content/browser/renderer_host/ui_events_helper.h b/content/browser/renderer_host/ui_events_helper.h
index 0bd516c..619197a 100644
--- a/content/browser/renderer_host/ui_events_helper.h
+++ b/content/browser/renderer_host/ui_events_helper.h
@@ -21,6 +21,11 @@ class TouchEvent;
 
 namespace content {
 
+enum TouchEventCoordinateSystem {
+  SCREEN_COORDINATES,
+  LOCAL_COORDINATES
+};
+
 // Creates a list of ui::TouchEvents out of a single WebTouchEvent.
 // A WebTouchEvent can contain information about a number of WebTouchPoints,
 // whereas a ui::TouchEvent contains information about a single touch-point. So
@@ -28,7 +33,8 @@ namespace content {
 // WebTouchEvent.
 CONTENT_EXPORT bool MakeUITouchEventsFromWebTouchEvents(
     const WebKit::WebTouchEvent& touch,
-    ScopedVector<ui::TouchEvent>* list);
+    ScopedVector<ui::TouchEvent>* list,
+    TouchEventCoordinateSystem coordinate_system);
 
 // Creates a WebGestureEvent from a ui::GestureEvent. Note that it does not
 // populate the event coordinates (i.e. |x|, |y|, |globalX|, and |globalY|). So