JNI: allow either JavaRef or bare objects in Java calls.

base/android/scoped_java_ref.h

 // 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.
 
 #ifndef BASE_ANDROID_SCOPED_JAVA_REF_H_
 #define BASE_ANDROID_SCOPED_JAVA_REF_H_
 
 #include <jni.h>
 #include <stddef.h>
 
@@ skipping 36 matching lines @@
   // empty ScopedJavaLocalRef just to pass null to a function with a JavaRef
   // parameter, and makes C++ "nullptr" and Java "null" equivalent.
   JavaRef(std::nullptr_t) : JavaRef() {}
 
   // Public to allow destruction of temporary JavaRef objects created by the
   // nullptr conversion. Don't add anything else here; it's inlined.
   ~JavaRef() {}
 
   jobject obj() const { return obj_; }
 
-  bool is_null() const { return obj_ == NULL; }
+  bool is_null() const { return obj_ == nullptr; }
 
  protected:
-  // Initializes a NULL reference. Don't add anything else here; it's inlined.
-  JavaRef() : obj_(NULL) {}
+  // Initializes a null reference. Don't add anything else here; it's inlined.
+  JavaRef() : obj_(nullptr) {}
 
   // Takes ownership of the |obj| reference passed; requires it to be a local
   // reference type.
 #if DCHECK_IS_ON()
   // Implementation contains a DCHECK; implement out-of-line when DCHECK_IS_ON.
   JavaRef(JNIEnv* env, jobject obj);
 #else
   // Don't add anything else here; it's inlined.
   JavaRef(JNIEnv* env, jobject obj) : obj_(obj) {}
 #endif
@@ skipping 65 matching lines @@
 // destroyed. Therefore, since a JNIEnv is only suitable for use on a single
 // thread, objects of this class must be created, used, and destroyed, on a
 // single thread.
 // Therefore, this class should only be used as a stack-based object and from a
 // single thread. If you wish to have the reference outlive the current
 // callstack (e.g. as a class member) or you wish to pass it across threads,
 // use a ScopedJavaGlobalRef instead.
 template<typename T>
 class ScopedJavaLocalRef : public JavaRef<T> {
  public:
-  ScopedJavaLocalRef() : env_(NULL) {}
+  ScopedJavaLocalRef() : env_(nullptr) {}
 
   // Non-explicit copy constructor, to allow ScopedJavaLocalRef to be returned
   // by value as this is the normal usage pattern.
   ScopedJavaLocalRef(const ScopedJavaLocalRef<T>& other)
       : env_(other.env_) {
     this->SetNewLocalRef(env_, other.obj());
   }
 
-  template<typename U>
-  explicit ScopedJavaLocalRef(const U& other)
-      : env_(NULL) {
+  template <typename U>
+  explicit ScopedJavaLocalRef(const U& other) : env_(nullptr) {
     this->Reset(other);
   }
 
   // Assumes that |obj| is a local reference to a Java object and takes
   // ownership  of this local reference.
   ScopedJavaLocalRef(JNIEnv* env, T obj) : JavaRef<T>(env, obj), env_(env) {}
 
   ~ScopedJavaLocalRef() {
     this->Reset();
   }
@@ skipping 11 matching lines @@
   template<typename U>
   void Reset(const ScopedJavaLocalRef<U>& other) {
     // We can copy over env_ here as |other| instance must be from the same
     // thread as |this| local ref. (See class comment for multi-threading
     // limitations, and alternatives).
     this->Reset(other.env_, other.obj());
   }
 
   template<typename U>
   void Reset(const U& other) {
-    // If |env_| was not yet set (is still NULL) it will be attached to the
+    // If |env_| was not yet set (is still null) it will be attached to the
     // current thread in SetNewLocalRef().
     this->Reset(env_, other.obj());
   }
 
   template<typename U>
   void Reset(JNIEnv* env, U obj) {
     static_assert(std::is_convertible<U, T>::value,
                   "U must be convertible to T");
     env_ = this->SetNewLocalRef(env, obj);
   }
@@ skipping 47 matching lines @@
   void operator=(const ScopedJavaGlobalRef<T>& other) {
     this->Reset(other);
   }
 
   void Reset() {
     this->ResetGlobalRef();
   }
 
   template<typename U>
   void Reset(const U& other) {
-    this->Reset(NULL, other.obj());
+    this->Reset(nullptr, other.obj());
   }
 
   template<typename U>
   void Reset(JNIEnv* env, const JavaParamRef<U>& other) {
     this->Reset(env, other.obj());
   }
 
   template<typename U>
   void Reset(JNIEnv* env, U obj) {
     static_assert(std::is_convertible<U, T>::value,
                   "U must be convertible to T");
     this->SetNewGlobalRef(env, obj);
   }
 
   // Releases the global reference to the caller. The caller *must* delete the
   // global reference when it is done with it. Note that calling a Java method
   // is *not* a transfer of ownership and Release() should not be used.
   T Release() {
     return static_cast<T>(this->ReleaseInternal());
   }
 };
 
+// Temporary type for parameters to Java functions, to allow incremental
+// migration from bare jobject to JavaRef. Don't use outside JNI generator.
+template <typename T>
+class JavaRefOrBare {
+ public:
+  JavaRefOrBare(std::nullptr_t) : obj_(nullptr) {}
+  JavaRefOrBare(const JavaRef<T>& ref) : obj_(ref.obj()) {}
+  JavaRefOrBare(T obj) : obj_(obj) {}
+  T obj() const { return obj_; }
+
+ private:
+  T obj_;
+
+  DISALLOW_COPY_AND_ASSIGN(JavaRefOrBare);
+};
+
 }  // namespace android
 }  // namespace base
 
 #endif  // BASE_ANDROID_SCOPED_JAVA_REF_H_