android: JavaRef type behaviour improvements.

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 26 matching lines @@
 
 // Forward declare the generic java reference template class.
 template<typename T> class JavaRef;
 
 // Template specialization of JavaRef, which acts as the base class for all
 // other JavaRef<> template types. This allows you to e.g. pass
 // ScopedJavaLocalRef<jstring> into a function taking const JavaRef<jobject>&
 template<>
 class BASE_EXPORT JavaRef<jobject> {
  public:
+  // Initializes a null reference. Don't add anything else here; it's inlined.
+  JavaRef() : obj_(nullptr) {}
+
   // Allow nullptr to be converted to JavaRef. This avoids having to declare an
-  // empty ScopedJavaLocalRef just to pass null to a function with a JavaRef
-  // parameter, and makes C++ "nullptr" and Java "null" equivalent.
+  // empty JavaRef just to pass null to a function, 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.
+  // Public to allow destruction of null JavaRef objects.
+  // Don't add anything else here; it's inlined.
   ~JavaRef() {}
 
   jobject obj() const { return obj_; }
 
   bool is_null() const { return obj_ == nullptr; }
 
  protected:
-  // 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 12 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(JavaRef);
 };
 
 // Generic base class for ScopedJavaLocalRef and ScopedJavaGlobalRef. Useful
 // for allowing functions to accept a reference without having to mandate
 // whether it is a local or global type.
 template<typename T>
 class JavaRef : public JavaRef<jobject> {
  public:
+  JavaRef() {}
   JavaRef(std::nullptr_t) : JavaRef<jobject>(nullptr) {}
   ~JavaRef() {}
 
   T obj() const { return static_cast<T>(JavaRef<jobject>::obj()); }
 
  protected:
-  JavaRef() {}
-
   JavaRef(JNIEnv* env, T obj) : JavaRef<jobject>(env, obj) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(JavaRef);
 };
 
 // Holds a local reference to a JNI method parameter.
 // Method parameters should not be deleted, and so this class exists purely to
 // wrap them as a JavaRef<T> in the JNI binding generator. Do not create
 // instances manually.
@@ skipping 40 matching lines @@
   // by value as this is the normal usage pattern.
   ScopedJavaLocalRef(const ScopedJavaLocalRef<T>& other)
       : env_(other.env_) {
     this->SetNewLocalRef(env_, other.obj());
   }
 
   ScopedJavaLocalRef(ScopedJavaLocalRef<T>&& other) : env_(other.env_) {
     this->swap(other);
   }
 
-  template <typename U>
-  explicit ScopedJavaLocalRef(const U& other) : env_(nullptr) {
+  explicit ScopedJavaLocalRef(const JavaRef<T>& other) : env_(nullptr) {
     this->Reset(other);
   }
 
   // Assumes that |obj| is a local reference to a Java object and takes
   // ownership  of this local reference.
+  // TODO(torne): this shouldn't be used outside of JNI helper functions but
+  // there are currently some cases where there aren't helpers for things.
   ScopedJavaLocalRef(JNIEnv* env, T obj) : JavaRef<T>(env, obj), env_(env) {}
 
   ~ScopedJavaLocalRef() {
     this->Reset();
   }
 
   // Overloaded assignment operator defined for consistency with the implicit
   // copy constructor.
   void operator=(const ScopedJavaLocalRef<T>& other) {
     this->Reset(other);
   }
 
   void operator=(ScopedJavaLocalRef<T>&& other) {
     env_ = other.env_;
     this->swap(other);
   }
 
   void Reset() {
     this->ResetLocalRef(env_);
   }
 
-  template<typename U>
-  void Reset(const ScopedJavaLocalRef<U>& other) {
+  void Reset(const ScopedJavaLocalRef<T>& 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) {
+  void Reset(const JavaRef<T>& other) {
     // 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);
-  }
+  // Creates a new local reference to the Java object, unlike the constructor
+  // with the same parameters that takes ownership of the existing reference.
+  // TODO(torne): these should match as this is confusing.
+  void Reset(JNIEnv* env, T obj) { env_ = this->SetNewLocalRef(env, obj); }
 
   // Releases the local reference to the caller. The caller *must* delete the
   // local 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());
   }
 
  private:
   // This class is only good for use on the thread it was created on so
@@ skipping 19 matching lines @@
   ScopedJavaGlobalRef(std::nullptr_t) {}
 
   ScopedJavaGlobalRef(const ScopedJavaGlobalRef<T>& other) {
     this->Reset(other);
   }
 
   ScopedJavaGlobalRef(ScopedJavaGlobalRef<T>&& other) { this->swap(other); }
 
   ScopedJavaGlobalRef(JNIEnv* env, T obj) { this->Reset(env, obj); }
 
-  template<typename U>
-  explicit ScopedJavaGlobalRef(const U& other) {
-    this->Reset(other);
-  }
+  explicit ScopedJavaGlobalRef(const JavaRef<T>& other) { this->Reset(other); }
 
   ~ScopedJavaGlobalRef() {
     this->Reset();
   }
 
   // Overloaded assignment operator defined for consistency with the implicit
   // copy constructor.
   void operator=(const ScopedJavaGlobalRef<T>& other) {
     this->Reset(other);
   }
 
   void operator=(ScopedJavaGlobalRef<T>&& other) { this->swap(other); }
 
   void Reset() {
     this->ResetGlobalRef();
   }
 
-  template<typename U>
-  void Reset(const U& other) {
-    this->Reset(nullptr, other.obj());
-  }
+  void Reset(const JavaRef<T>& other) { this->Reset(nullptr, other.obj()); }
 
-  template<typename U>
-  void Reset(JNIEnv* env, const JavaParamRef<U>& other) {
+  void Reset(JNIEnv* env, const JavaParamRef<T>& 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);
-  }
+  void Reset(JNIEnv* env, T obj) { 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_