SyntheticGestureTarget implementation for injecting synthetic input events

content/browser/renderer_host/input/synthetic_gesture_target_base.h

 // Copyright 2013 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.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_TARGET_H_
-#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_TARGET_H_
+#ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_TARGET_BASE_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_TARGET_BASE_H_
 
 #include "base/time/time.h"
-#include "content/browser/renderer_host/input/synthetic_gesture_new.h"
-#include "content/common/content_export.h"
-#include "content/common/input/synthetic_gesture_params.h"
+#include "content/browser/renderer_host/input/synthetic_gesture_target.h"
+
+namespace ui {
+struct LatencyInfo;
+}
+
+namespace WebKit {
+class WebTouchEvent;
+}
 
 namespace content {
 
-class InputEvent;
+class RenderWidgetHostView;
 
-// Interface between the synthetic gesture controller and the RWHV.
-class CONTENT_EXPORT SyntheticGestureTarget {
+class SyntheticGestureTargetBase : public SyntheticGestureTarget {
  public:
-  virtual void QueueInputEventToPlatform(const InputEvent& event) = 0;
+  SyntheticGestureTargetBase(RenderWidgetHostView* render_view);
+  ~SyntheticGestureTargetBase();
+
+  virtual void QueueWebTouchEventToPlatform(
+      const WebKit::WebTouchEvent& web_touch,
+      const ui::LatencyInfo& latency_info);
+
+  // SyntheticGestureTarget:
+  virtual void QueueInputEventToPlatform(const InputEvent& event) OVERRIDE;

[Dominik Grewe, 2013/10/25 16:10:11]

I'm wondering if it's better to override this method in the sub-classes rather
than rely on this one. If, for example, on Android we don't support mouse
events, do we want to fall back to Base or do we want to fail? I thought the
latter, that's why we have SupportsSyntheticGestureSourceType(), but I guess
both options have their advantages.

Also, in Base there's no need to distinguish between different types of events
if we simply forward them as-is to RWH.

[kouhei (in TOK), 2013/10/28 03:03:17]

I'm not sure here. I added DCHECKs for unsupported GestureSourceType calls.
This is true in future, but currently we need to use separate forward method per
type. (e.g. Forward{MouseWheel,Touch}EventWithLatencyInfo)

 
   virtual void OnSyntheticGestureCompleted(
-      SyntheticGestureNew::Result result) = 0;
+      SyntheticGestureNew::Result result) OVERRIDE;
 
-  virtual base::TimeDelta GetSyntheticGestureUpdateRate() const = 0;
+  virtual base::TimeDelta GetSyntheticGestureUpdateRate() const OVERRIDE;
 
   virtual SyntheticGestureParams::GestureSourceType
-      GetDefaultSyntheticGestureSourceType() const = 0;
+      GetDefaultSyntheticGestureSourceType() const OVERRIDE;
   virtual bool SupportsSyntheticGestureSourceType(
-      SyntheticGestureParams::GestureSourceType gesture_source_type) const = 0;
+      SyntheticGestureParams::GestureSourceType gesture_source_type) const
+      OVERRIDE;
+
+ protected:
+  RenderWidgetHostView* render_view() { return render_view_; }
+
+ private:
+  RenderWidgetHostView* render_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyntheticGestureTargetBase);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_TARGET_H_
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_SYNTHETIC_GESTURE_TARGET_BASE_H_