Add AsyncWaiter implementation to java API.

mojo/android/system/core_impl.cc

 // Copyright 2014 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 "mojo/android/system/core_impl.h"
 
 #include "base/android/base_jni_registrar.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_registrar.h"
 #include "base/android/library_loader/library_loader_hooks.h"
-#include "base/logging.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
 #include "jni/CoreImpl_jni.h"
 #include "mojo/embedder/embedder.h"
+#include "mojo/public/c/environment/async_waiter.h"
 #include "mojo/public/c/system/core.h"
+#include "mojo/public/cpp/environment/default_async_waiter.h"
+
+namespace {
+
+// |AsyncWait| is guaranteed never to return 0.
+const MojoAsyncWaitID kInvalidHandleCancelID = 0;
+
+struct AsyncWaitCallbackData {
+  base::android::ScopedJavaGlobalRef<jobject> core_impl;
+  base::android::ScopedJavaGlobalRef<jobject> callback;
+  base::android::ScopedJavaGlobalRef<jobject> cancellable;
+
+  AsyncWaitCallbackData(JNIEnv* env, jobject core_impl, jobject callback) {
+    this->core_impl.Reset(env, core_impl);
+    this->callback.Reset(env, callback);
+  }
+};
+
+void AsyncWaitCallback(void* data, MojoResult result) {
+  scoped_ptr<AsyncWaitCallbackData> callback_data(
+      static_cast<AsyncWaitCallbackData*>(data));
+  mojo::android::Java_CoreImpl_onAsyncWaitResult(
+      base::android::AttachCurrentThread(),
+      callback_data->core_impl.obj(),
+      result,
+      callback_data->callback.obj(),
+      callback_data->cancellable.obj());
+}
+
+}  // namespace
 
 namespace mojo {
 namespace android {
 
 static void Constructor(JNIEnv* env, jobject jcaller) {
   mojo::embedder::Init();
 }
 
 static jlong GetTimeTicksNow(JNIEnv* env, jobject jcaller) {
   return MojoGetTimeTicksNow();
@@ skipping 253 matching lines @@
   return Java_CoreImpl_newNativeCodeAndBufferResult(env, result, byte_buffer)
       .Release();
 }
 
 static int Unmap(JNIEnv* env, jobject jcaller, jobject buffer) {
   void* buffer_start = env->GetDirectBufferAddress(buffer);
   DCHECK(buffer_start);
   return MojoUnmapBuffer(buffer_start);
 }
 
+static jobject AsyncWait(JNIEnv* env,
+                         jobject jcaller,
+                         jint mojo_handle,
+                         jint flags,
+                         jlong deadline,
+                         jobject callback) {
+  AsyncWaitCallbackData* callback_data =
+      new AsyncWaitCallbackData(env, jcaller, callback);
+  MojoAsyncWaitID cancel_id;
+  if (static_cast<MojoHandle>(mojo_handle) != MOJO_HANDLE_INVALID) {
+    MojoAsyncWaiter* async_waiter = mojo::GetDefaultAsyncWaiter();
+    cancel_id = async_waiter->AsyncWait(async_waiter,
+                                        mojo_handle,
+                                        flags,
+                                        deadline,
+                                        AsyncWaitCallback,
+                                        callback_data);
+  } else {
+    cancel_id = kInvalidHandleCancelID;
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &AsyncWaitCallback, callback_data, MOJO_RESULT_INVALID_ARGUMENT));
+  }
+  base::android::ScopedJavaLocalRef<jobject> cancellable =
+      Java_CoreImpl_newAsyncWaiterCancellableImpl(
+          env, jcaller, cancel_id, reinterpret_cast<intptr_t>(callback_data));
+  callback_data->cancellable.Reset(env, cancellable.obj());
+  return cancellable.Release();
+}
+
+static void CancelAsyncWait(JNIEnv* env,
+                            jobject jcaller,
+                            jlong id,
+                            jlong data_ptr) {
+  if (id == 0) {
+    // If |id| is |kInvalidHandleCancelID|, the async wait was done on an
+    // invalid handle, so the AsyncWaitCallback will be called and will clear
+    // the data_ptr.
+    return;
+  }
+  scoped_ptr<AsyncWaitCallbackData> deleter(
+      reinterpret_cast<AsyncWaitCallbackData*>(
+          static_cast<intptr_t>(data_ptr)));
+  MojoAsyncWaiter* async_waiter = mojo::GetDefaultAsyncWaiter();
+  async_waiter->CancelWait(async_waiter, id);
+}
+
 bool RegisterCoreImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace mojo