SyntheticGestureTarget implementation for injecting synthetic input events

content/browser/renderer_host/synthetic_touch_event_android.cc

+// 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.
+
+#include "content/browser/renderer_host/synthetic_touch_event_android.h"
+
+#include "content/browser/android/content_view_core_impl.h"
+#include "jni/SyntheticTouchEvent_jni.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+
+namespace {
+bool g_jni_initialized = false;
+
+void RegisterNativesIfNeeded(JNIEnv* env) {
+  if (!g_jni_initialized) {
+    content::RegisterNativesImpl(env);
+    g_jni_initialized = true;
+  }
+}
+}  // namespace
+
+namespace content {
+
+SyntheticTouchEventAndroid::SyntheticTouchEventAndroid(
+    ContentViewCoreImpl* content_view_core)
+    : env_(base::android::AttachCurrentThread()),
+      java_touch_event_(content_view_core->CreateSyntheticTouchEvent()),
+      savedDownTime_(0) {
+  CHECK(! java_touch_event_.is_null());
+  RegisterNativesIfNeeded(env_);
+}
+
+SyntheticTouchEventAndroid::~SyntheticTouchEventAndroid() {
+}
+
+void SyntheticTouchEventAndroid::reset() {
+  Java_SyntheticTouchEvent_reset(env_, java_touch_event_.obj());
+}
+
+long SyntheticTouchEventAndroid::GetCurrentTime() {
+  return Java_SyntheticTouchEvent_getCurrentTime(env_);
+}
+
+void SyntheticTouchEventAndroid::SetDownTime(long downTime) {
+  Java_SyntheticTouchEvent_setDownTime(env_, java_touch_event_.obj(),
+                                       downTime);
+}
+
+void SyntheticTouchEventAndroid::AddPointer(int x, int y, int id) {
+  Java_SyntheticTouchEvent_addPointer(env_, java_touch_event_.obj(), x, y, id);
+}
+
+void SyntheticTouchEventAndroid::Inject(Action action) {
+  Java_SyntheticTouchEvent_inject(env_, java_touch_event_.obj(),
+                                  static_cast<int>(action));
+}
+
+void SyntheticTouchEventAndroid::InjectWebTouchEvent(
+    const WebKit::WebTouchEvent* web_touch) {
+  reset();

[Dominik Grewe, 2013/10/10 14:01:45]

If I understand correctly you're trying to make the Java side kind of stateless,
i.e. the state across the entire gesture (savedDownTime_) is only stored on the
C++ side. That's why you reset the Java object each time, right? (and to reset
mPointerCount).

I'm wondering if the overhead of all the JNI calls is worth that. If you didn't
reset mDownTime on the Java side you wouldn't have to set it again each time.
But maybe the overhead is negligible. What do you think?

[kouhei (in TOK), 2013/10/15 02:10:02]

I think the cost of reset() here is negligible, as we are already doing JNI call
N_pointers+2 times. If we got rid of reset(), this will still JNI call
N_pointers+1 times.

[Dominik Grewe, 2013/10/15 09:10:55]

You would also save the call to SetDownTime() on each call. Given that
N_pointers is likely to be small (1 or 2) you could cut about half the JNI calls
on average. But like I said, I don't know if it's worth it overall.

[jdduke (slow), 2013/10/16 15:05:25]

While JNI calls are "slow", that is only in the relative sense; the overhead is
still in the order of just tens of nanoseconds. So, unless they're being called
thousands of times a frame, we should not be optimizing JNI calls here.  We
should do whatever is simplest.

[kouhei (in TOK), 2013/10/17 05:44:13]

Thanks for your comments! I think I can go with the stateful version with less
JNI calls, it wasn't confusing as I first thought.

+
+  SyntheticTouchEventAndroid::Action action =
+      SyntheticTouchEventAndroid::ActionInvalid;
+  switch (web_touch->type) {
+    case WebKit::WebInputEvent::TouchStart:
+      action = SyntheticTouchEventAndroid::ActionStart;
+      savedDownTime_ = GetCurrentTime();
+      break;
+    case WebKit::WebInputEvent::TouchMove:
+      action = SyntheticTouchEventAndroid::ActionMove;
+      break;
+    case WebKit::WebInputEvent::TouchCancel:
+      action = SyntheticTouchEventAndroid::ActionCancel;
+      break;
+    case WebKit::WebInputEvent::TouchEnd:
+      action = SyntheticTouchEventAndroid::ActionEnd;
+      break;
+    default:
+      NOTREACHED();
+  }
+  DCHECK(savedDownTime_ > 0);
+  SetDownTime(savedDownTime_);
+
+  const unsigned num_touches = web_touch->touchesLength;
+  for (unsigned i = 0; i < num_touches; ++ i) {
+    const WebKit::WebTouchPoint* point = &web_touch->touches[i];
+    AddPointer(point->position.x, point->position.y, point->id);
+  }
+
+  Inject(action);
+
+  if (web_touch->type == WebKit::WebInputEvent::TouchCancel ||
+      web_touch->type == WebKit::WebInputEvent::TouchEnd)
+    savedDownTime_ = 0;
+}
+
+}  // namespace content