Home | History | Annotate | Download | only in system 
      1 // Copyright 2016 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "mojo/android/system/watcher_impl.h"
      6 
      7 #include <stddef.h>
      8 #include <stdint.h>
      9 
     10 #include "base/android/base_jni_registrar.h"
     11 #include "base/android/jni_android.h"
     12 #include "base/android/jni_registrar.h"
     13 #include "base/android/library_loader/library_loader_hooks.h"
     14 #include "base/android/scoped_java_ref.h"
     15 #include "base/bind.h"
     16 #include "jni/WatcherImpl_jni.h"
     17 #include "mojo/public/cpp/system/handle.h"
     18 #include "mojo/public/cpp/system/watcher.h"
     19 
     20 namespace mojo {
     21 namespace android {
     22 
     23 using base::android::JavaParamRef;
     24 
     25 namespace {
     26 
     27 class WatcherImpl {
     28  public:
     29   WatcherImpl() : watcher_(FROM_HERE) {}
     30 
     31   ~WatcherImpl() = default;
     32 
     33   jint Start(JNIEnv* env,
     34              const JavaParamRef<jobject>& jcaller,
     35              jint mojo_handle,
     36              jint signals) {
     37     java_watcher_.Reset(env, jcaller);
     38 
     39     auto ready_callback =
     40         base::Bind(&WatcherImpl::OnHandleReady, base::Unretained(this));
     41 
     42     MojoResult result =
     43         watcher_.Start(mojo::Handle(static_cast<MojoHandle>(mojo_handle)),
     44                        static_cast<MojoHandleSignals>(signals), ready_callback);
     45 
     46     if (result != MOJO_RESULT_OK)
     47       java_watcher_.Reset();
     48 
     49     return result;
     50   }
     51 
     52   void Cancel() {
     53     java_watcher_.Reset();
     54     watcher_.Cancel();
     55   }
     56 
     57  private:
     58   void OnHandleReady(MojoResult result) {
     59     DCHECK(!java_watcher_.is_null());
     60 
     61     base::android::ScopedJavaGlobalRef<jobject> java_watcher_preserver;
     62     if (result == MOJO_RESULT_CANCELLED)
     63       java_watcher_preserver = std::move(java_watcher_);
     64 
     65     Java_WatcherImpl_onHandleReady(
     66         base::android::AttachCurrentThread(),
     67         java_watcher_.is_null() ? java_watcher_preserver : java_watcher_,
     68         result);
     69   }
     70 
     71   Watcher watcher_;
     72   base::android::ScopedJavaGlobalRef<jobject> java_watcher_;
     73 
     74   DISALLOW_COPY_AND_ASSIGN(WatcherImpl);
     75 };
     76 
     77 }  // namespace
     78 
     79 static jlong CreateWatcher(JNIEnv* env, const JavaParamRef<jobject>& jcaller) {
     80   return reinterpret_cast<jlong>(new WatcherImpl);
     81 }
     82 
     83 static jint Start(JNIEnv* env,
     84                   const JavaParamRef<jobject>& jcaller,
     85                   jlong watcher_ptr,
     86                   jint mojo_handle,
     87                   jint signals) {
     88   auto* watcher = reinterpret_cast<WatcherImpl*>(watcher_ptr);
     89   return watcher->Start(env, jcaller, mojo_handle, signals);
     90 }
     91 
     92 static void Cancel(JNIEnv* env,
     93                    const JavaParamRef<jobject>& jcaller,
     94                    jlong watcher_ptr) {
     95   reinterpret_cast<WatcherImpl*>(watcher_ptr)->Cancel();
     96 }
     97 
     98 static void Delete(JNIEnv* env,
     99                    const JavaParamRef<jobject>& jcaller,
    100                    jlong watcher_ptr) {
    101   delete reinterpret_cast<WatcherImpl*>(watcher_ptr);
    102 }
    103 
    104 bool RegisterWatcherImpl(JNIEnv* env) {
    105   return RegisterNativesImpl(env);
    106 }
    107 
    108 }  // namespace android
    109 }  // namespace mojo
    110