[android_webview] Add a generic callback JNI bridge.

android_webview/java/src/org/chromium/android_webview/CallbackJNIBridge.java

Index: android_webview/java/src/org/chromium/android_webview/CallbackJNIBridge.java
diff --git a/android_webview/java/src/org/chromium/android_webview/CallbackJNIBridge.java b/android_webview/java/src/org/chromium/android_webview/CallbackJNIBridge.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7827509dd9364d27fadccdd20b14a3bb2efd596
--- /dev/null
+++ b/android_webview/java/src/org/chromium/android_webview/CallbackJNIBridge.java
@@ -0,0 +1,84 @@
+// 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.
+
+package org.chromium.android_webview;
+
+import android.webkit.ValueCallback;
+
+import org.chromium.base.CalledByNative;
+import org.chromium.base.JNINamespace;
+
+/*
+ * Use case A:
+ *
+ * in Java:
+ *
+ * doSomethingInCpp(new ValueCallback<Integer>() {
+ *  @Override
+ *  public void onReceiveValue(int value) {
+ *    ..stuff..
+ *  }
+ * });
+ *
+ * in C++:
+ * void object::doSomethingInCpp(jobject intCallback) {
+ * base::Callback<int> callback = CallbackJNIBridge::FromJavaValueCallbackInt(intCallback);
+ * callback.Run(1) ----> anon_object.onReceiveValue(1); gets called Java-side
+ *
+ * ------------------------------------------------------------------------------------------------
+ * Use case B:
+ *
+ * in C++
+ * android::ScopedLocalJavaRef jcallback = JavaIntCallback(object, &Object::onIntValue);

[mkosiba (inactive), 2013/02/21 19:28:24]

uh.. didn't update this - it should be
  ... = CallbackJNIBridge::ToJavaValueCallbackInt(
      base::Bind(&Object::onIntValue, object));

+ * doSomethingInJava(jcallback.obj());
+ *
+ * in Java:
+ * private void doSomethingInJava(ValueCallback<Int> vc) {
+ *  int value;
+ *  ...
+ *  value = 3;
+ *  ...
+ *  vc.onReceiveValue(value); // --> calls object->onIntValue(3);
+ * }
+ *
+ */
+
+@JNINamespace("android_webview")
+class CallbackJNIBridge {
+    @SuppressWarnings("unchecked")

[mkosiba (inactive), 2013/02/21 19:26:42]

I'll probably want to go the direction of having separate interfaces for
different types as type erasure is making use of webkit.ValueCallback a bit
unsafe.

Also, the JNI generator doesn't understand templates, which makes using
ValueCallback directly even more problematic.

+    @CalledByNative
+    public static void invokeValueCallbackInt(ValueCallback callback, int value) {
+        callback.onReceiveValue(value);
+    }
+
+    @CalledByNative
+    public static ValueCallback createValueCallbackInt(final int nativeCallback) {
+        return new ValueCallback<Integer>() {
+            private int mNativeCallback = nativeCallback;
+
+            @Override
+            public void onReceiveValue(Integer value) {
+                assert mNativeCallback != 0;
+                if (mNativeCallback != 0) {
+                    nativeOnReceiveValueInt(mNativeCallback, value);
+                    clear();

[mkosiba (inactive), 2013/02/21 19:26:42]

the idea here is that these are one-shot callbacks, which simplifies memory
management a lot. Depending on the finalizer to always free up native resources
seems like asking for trouble...

[joth, 2013/02/21 23:30:47]

THe other pattern oft used is to couple the native object lifetime to something
else suitably scoped (e.g. a map<int, Foo> inside AwContents) and just hold the
int on the java side (i.e. a weak ref)
this doesn't really work here for the case of a generic library.

[mkosiba (inactive), 2013/02/22 18:54:31]

I was considering whether I should make the CallbackJNIBridge be a member of
whatever class is using it. That way it would be easier to bind the lifetime of
the callback to the object that's holding on to the Bridge but would make using
the Bridge a lot less convenient...

+                }
+            }
+
+            @Override
+            protected void finalize() throws Throwable {

[joth, 2013/02/21 23:30:47]

use CleanupReference rather than finalizer

[mkosiba (inactive), 2013/02/22 18:54:31]

ok

+                clear();
+            }
+
+            private void clear() {
+                if (mNativeCallback != 0) {
+                    nativeDestroyInt(mNativeCallback);
+                }
+            }
+        };
+    }
+
+    private static native void nativeOnReceiveValueInt(int callbackInt, int value);
+    private static native void nativeDestroyInt(int callbackInt);
+}