Add functions to convert boolean jni array.

base/android/jni_array.cc

 // 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.
 
 #include "base/android/jni_array.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 
@@ skipping 27 matching lines @@
 
   return ScopedJavaLocalRef<jbyteArray>(env, byte_array);
 }
 
 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
     JNIEnv* env,
     const std::vector<uint8_t>& bytes) {
   return ToJavaByteArray(env, bytes.data(), bytes.size());
 }
 
+ScopedJavaLocalRef<jbooleanArray> ToJavaBooleanArray(JNIEnv* env,
+                                                     const bool* bools,
+                                                     size_t len) {
+  jbooleanArray boolean_array = env->NewBooleanArray(len);
+  CheckException(env);
+  DCHECK(boolean_array);
+
+  env->SetBooleanArrayRegion(boolean_array, 0, len,
+                             reinterpret_cast<const jboolean*>(bools));
+  CheckException(env);
+
+  return ScopedJavaLocalRef<jbooleanArray>(env, boolean_array);
+}
+
 ScopedJavaLocalRef<jintArray> ToJavaIntArray(
     JNIEnv* env, const int* ints, size_t len) {
   jintArray int_array = env->NewIntArray(len);
   CheckException(env);
   DCHECK(int_array);
 
   env->SetIntArrayRegion(
       int_array, 0, len, reinterpret_cast<const jint*>(ints));
   CheckException(env);
 
@@ skipping 92 matching lines @@
                                          std::vector<string16>* out) {
   DCHECK(out);
   if (!array)
     return;
   size_t len = SafeGetArrayLength(env, array);
   size_t back = out->size();
   out->resize(back + len);
   for (size_t i = 0; i < len; ++i) {
     ScopedJavaLocalRef<jstring> str(env,
         static_cast<jstring>(env->GetObjectArrayElement(array, i)));
-    ConvertJavaStringToUTF16(env, str.obj(), &((*out)[back + i]));
+    ConvertJavaStringToUTF16(env, str.obj(), out->data() + back + i);
   }
 }
 
 void AppendJavaStringArrayToStringVector(JNIEnv* env,
                                          jobjectArray array,
                                          std::vector<std::string>* out) {
   DCHECK(out);
   if (!array)
     return;
   size_t len = SafeGetArrayLength(env, array);
   size_t back = out->size();
   out->resize(back + len);
   for (size_t i = 0; i < len; ++i) {
     ScopedJavaLocalRef<jstring> str(env,
         static_cast<jstring>(env->GetObjectArrayElement(array, i)));
-    ConvertJavaStringToUTF8(env, str.obj(), &((*out)[back + i]));
+    ConvertJavaStringToUTF8(env, str.obj(), out->data() + back + i);
   }
 }
 
 void AppendJavaByteArrayToByteVector(JNIEnv* env,
                                      jbyteArray byte_array,
                                      std::vector<uint8_t>* out) {
   DCHECK(out);
   if (!byte_array)
     return;
   size_t len = SafeGetArrayLength(env, byte_array);
   if (!len)
     return;
   size_t back = out->size();
   out->resize(back + len);
   env->GetByteArrayRegion(byte_array, 0, len,
-                          reinterpret_cast<int8_t*>(&(*out)[back]));
+                          reinterpret_cast<int8_t*>(out->data() + back));
 }
 
 void JavaByteArrayToByteVector(JNIEnv* env,
                                jbyteArray byte_array,
                                std::vector<uint8_t>* out) {
   DCHECK(out);
   DCHECK(byte_array);
   out->clear();
   AppendJavaByteArrayToByteVector(env, byte_array, out);
 }
 
+void JavaBooleanArrayToBoolVector(JNIEnv* env,
+                                  jbooleanArray boolean_array,
+                                  std::vector<bool>* out) {
+  DCHECK(out);
+  if (!boolean_array)
+    return;
+  size_t len = SafeGetArrayLength(env, boolean_array);
+  if (!len)
+    return;
+  out->resize(len);
+  // It is not possible to get bool* out of vector<bool>.
+  jboolean* values = env->GetBooleanArrayElements(boolean_array, nullptr);
+  for (size_t i = 0; i < len; ++i) {
+    out->at(i) = static_cast<bool>(values[i]);
+  }
+}
+
 void JavaIntArrayToIntVector(JNIEnv* env,
                              jintArray int_array,
                              std::vector<int>* out) {
   DCHECK(out);
   size_t len = SafeGetArrayLength(env, int_array);
   out->resize(len);
   if (!len)
     return;
-  // TODO(jdduke): Use |out->data()| for pointer access after switch to libc++,
-  // both here and in the other conversion routines. See crbug.com/427718.
-  env->GetIntArrayRegion(int_array, 0, len, &(*out)[0]);
+  env->GetIntArrayRegion(int_array, 0, len, out->data());
 }
 
 void JavaLongArrayToInt64Vector(JNIEnv* env,
                                 jlongArray long_array,
                                 std::vector<int64_t>* out) {
   DCHECK(out);
   std::vector<jlong> temp;
   JavaLongArrayToLongVector(env, long_array, &temp);
   out->resize(0);
   out->insert(out->begin(), temp.begin(), temp.end());
 }
 
 void JavaLongArrayToLongVector(JNIEnv* env,
                                jlongArray long_array,
                                std::vector<jlong>* out) {
   DCHECK(out);
   size_t len = SafeGetArrayLength(env, long_array);
   out->resize(len);
   if (!len)
     return;
-  env->GetLongArrayRegion(long_array, 0, len, &(*out)[0]);
+  env->GetLongArrayRegion(long_array, 0, len, out->data());
 }
 
 void JavaFloatArrayToFloatVector(JNIEnv* env,
                                  jfloatArray float_array,
                                  std::vector<float>* out) {
   DCHECK(out);
   size_t len = SafeGetArrayLength(env, float_array);
   out->resize(len);
   if (!len)
     return;
-  env->GetFloatArrayRegion(float_array, 0, len, &(*out)[0]);
+  env->GetFloatArrayRegion(float_array, 0, len, out->data());
 }
 
 void JavaArrayOfByteArrayToStringVector(
     JNIEnv* env,
     jobjectArray array,
     std::vector<std::string>* out) {
   DCHECK(out);
   size_t len = SafeGetArrayLength(env, array);
   out->resize(len);
   for (size_t i = 0; i < len; ++i) {
@@ skipping 10 matching lines @@
 void JavaArrayOfIntArrayToIntVector(
     JNIEnv* env,
     jobjectArray array,
     std::vector<std::vector<int>>* out) {
   DCHECK(out);
   size_t len = SafeGetArrayLength(env, array);
   out->resize(len);
   for (size_t i = 0; i < len; ++i) {
     ScopedJavaLocalRef<jintArray> int_array(
         env, static_cast<jintArray>(env->GetObjectArrayElement(array, i)));
-    JavaIntArrayToIntVector(env, int_array.obj(), &((*out)[i]));
+    JavaIntArrayToIntVector(env, int_array.obj(), &out->at(i));
   }
 }
 
 }  // namespace android
 }  // namespace base