Upstream Android JNI code, allowing us to use more ScopedJava references.

base/android/jni_array.cc

 // Copyright (c) 2011 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 "base/android/jni_array.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
-#include "base/android/scoped_java_ref.h"
 #include "base/logging.h"
 
 namespace base {
 namespace android {
 
-jbyteArray ToJavaByteArray(JNIEnv* env,
-                           const unsigned char* bytes,
-                           size_t len) {
+ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
+    JNIEnv* env, const uint8* bytes, size_t len) {
   jbyteArray byte_array = env->NewByteArray(len);
   CheckException(env);
   DCHECK(byte_array);
 
   jbyte* elements = env->GetByteArrayElements(byte_array, NULL);
   memcpy(elements, bytes, len);
   env->ReleaseByteArrayElements(byte_array, elements, 0);
   CheckException(env);
 
-  return byte_array;
+  return ScopedJavaLocalRef<jbyteArray>(env, byte_array);
 }
 
-jobjectArray ToJavaArrayOfByteArray(JNIEnv* env,
-                                    const std::vector<std::string>& v) {
-  ScopedJavaLocalRef<jclass> byte_array_clazz(env, env->FindClass("[B"));
+ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
+    JNIEnv* env, const std::vector<std::string>& v) {
+  ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B");
   jobjectArray joa = env->NewObjectArray(v.size(),
                                          byte_array_clazz.obj(), NULL);
   CheckException(env);
 
   for (size_t i = 0; i < v.size(); ++i) {
-    ScopedJavaLocalRef<jobject> byte_array(env, ToJavaByteArray(env,
-            reinterpret_cast<const uint8*>(v[i].data()), v[i].length()));
+    ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(env,
+        reinterpret_cast<const uint8*>(v[i].data()), v[i].length());
     env->SetObjectArrayElement(joa, i, byte_array.obj());
   }
-  return joa;
+  return ScopedJavaLocalRef<jobjectArray>(env, joa);
 }
 
-jobjectArray ToJavaArrayOfStrings(JNIEnv* env,
-                                  const std::vector<std::string>& v) {
-  ScopedJavaLocalRef<jclass> string_clazz(env,
-                                          env->FindClass("java/lang/String"));
+ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
+    JNIEnv* env, const std::vector<std::string>& v) {
+  ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String");
   jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL);
   CheckException(env);
 
   for (size_t i = 0; i < v.size(); ++i) {
-    ScopedJavaLocalRef<jstring> item(env,
-                                     ConvertUTF8ToJavaString(env, v[i]));
+    ScopedJavaLocalRef<jstring> item = ConvertUTF8ToJavaString(env, v[i]);
     env->SetObjectArrayElement(joa, i, item.obj());
   }
-  return joa;
+  return ScopedJavaLocalRef<jobjectArray>(env, joa);
+}
+
+void AppendJavaByteArrayToByteVector(JNIEnv* env,
+                                     jbyteArray byte_array,
+                                     std::vector<uint8>* out) {
+  DCHECK(out);
+  if (!byte_array)
+    return;
+  jsize len = env->GetArrayLength(byte_array);
+  jbyte* bytes = env->GetByteArrayElements(byte_array, NULL);
+  out->insert(out->end(), bytes, bytes + len);
+  env->ReleaseByteArrayElements(byte_array, bytes, JNI_ABORT);
+}
+
+void JavaByteArrayToByteVector(JNIEnv* env,
+                               jbyteArray byte_array,
+                               std::vector<uint8>* out) {
+  DCHECK(out);
+  out->clear();
+  AppendJavaByteArrayToByteVector(env, byte_array, out);
 }
 
 }  // namespace android
 }  // namespace base