Small improvements to JNI references.

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>
 
 #include <type_traits>
+#include <utility>
 
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/macros.h"
 
 namespace base {
 namespace android {
 
 // Creates a new local reference frame, in which at least a given number of
 // local references can be created. Note that local references already created
@@ skipping 41 matching lines @@
   // 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
 
+  void swap(JavaRef& other) { std::swap(obj_, other.obj_); }
+
   // The following are implementation detail convenience methods, for
   // use by the sub-classes.
   JNIEnv* SetNewLocalRef(JNIEnv* env, jobject obj);
   void SetNewGlobalRef(JNIEnv* env, jobject obj);
   void ResetLocalRef(JNIEnv* env);
   void ResetGlobalRef();
   jobject ReleaseInternal();
 
  private:
   jobject obj_;
@@ skipping 63 matching lines @@
  public:
   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());
   }
 
+  ScopedJavaLocalRef(ScopedJavaLocalRef<T>&& other) : env_(other.env_) {
+    this->swap(other);
+  }
+
   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();
   }
 
   // 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) {
     // 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());
@@ skipping 39 matching lines @@
 // imposed by the underlying Java object that it references).
 template<typename T>
 class ScopedJavaGlobalRef : public JavaRef<T> {
  public:
   ScopedJavaGlobalRef() {}
 
   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);
   }
 
   ~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());
   }
 
   template<typename U>
@@ skipping 29 matching lines @@
  private:
   T obj_;
 
   DISALLOW_COPY_AND_ASSIGN(JavaRefOrBare);
 };
 
 }  // namespace android
 }  // namespace base
 
 #endif  // BASE_ANDROID_SCOPED_JAVA_REF_H_