base/android: Change JNI array conversion helpers to take spans
Change helper methods ToJavaFooArray() and to ToJavaArrayOfFoo() to take
their input as base::span<> instead of const std::vector<>&. base::span
is implicitly converted from most array-like container types; so
existing callers work unmodified, and new callers can choose to convert
from other types like std::array<>.
Also add an overload of ToJavaArrayOfByteArray() that takes an input
bytes as std::vector<uint8_t> instead of std::string.
Change-Id: Ic9b9327220c4836c01b716299b3ce4ec973b32a5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2109036
Reviewed-by: Richard Coles <[email protected]>
Commit-Queue: Martin Kreichgauer <[email protected]>
Cr-Commit-Position: refs/heads/master@{#751764}
diff --git a/base/android/jni_array.cc b/base/android/jni_array.cc
index c339c39..9626abe 100644
--- a/base/android/jni_array.cc
+++ b/base/android/jni_array.cc
@@ -32,8 +32,8 @@
CheckException(env);
DCHECK(byte_array);
- env->SetByteArrayRegion(
- byte_array, 0, len, reinterpret_cast<const jbyte*>(bytes));
+ env->SetByteArrayRegion(byte_array, 0, len,
+ reinterpret_cast<const jbyte*>(bytes));
CheckException(env);
return ScopedJavaLocalRef<jbyteArray>(env, byte_array);
@@ -41,7 +41,7 @@
ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
JNIEnv* env,
- const std::vector<uint8_t>& bytes) {
+ base::span<const uint8_t> bytes) {
return ToJavaByteArray(env, bytes.data(), bytes.size());
}
@@ -65,21 +65,22 @@
return ScopedJavaLocalRef<jbooleanArray>(env, boolean_array);
}
-ScopedJavaLocalRef<jintArray> ToJavaIntArray(
- JNIEnv* env, const int* ints, size_t len) {
+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));
+ env->SetIntArrayRegion(int_array, 0, len,
+ reinterpret_cast<const jint*>(ints));
CheckException(env);
return ScopedJavaLocalRef<jintArray>(env, int_array);
}
-ScopedJavaLocalRef<jintArray> ToJavaIntArray(
- JNIEnv* env, const std::vector<int>& ints) {
+ScopedJavaLocalRef<jintArray> ToJavaIntArray(JNIEnv* env,
+ base::span<const int> ints) {
return ToJavaIntArray(env, ints.data(), ints.size());
}
@@ -90,8 +91,8 @@
CheckException(env);
DCHECK(long_array);
- env->SetLongArrayRegion(
- long_array, 0, len, reinterpret_cast<const jlong*>(longs));
+ env->SetLongArrayRegion(long_array, 0, len,
+ reinterpret_cast<const jlong*>(longs));
CheckException(env);
return ScopedJavaLocalRef<jlongArray>(env, long_array);
@@ -100,19 +101,19 @@
// Returns a new Java long array converted from the given int64_t array.
BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
JNIEnv* env,
- const std::vector<int64_t>& longs) {
+ base::span<const int64_t> longs) {
return ToJavaLongArray(env, longs.data(), longs.size());
}
// Returns a new Java float array converted from the given C++ float array.
-BASE_EXPORT ScopedJavaLocalRef<jfloatArray> ToJavaFloatArray(
- JNIEnv* env, const float* floats, size_t len) {
+BASE_EXPORT ScopedJavaLocalRef<jfloatArray>
+ToJavaFloatArray(JNIEnv* env, const float* floats, size_t len) {
jfloatArray float_array = env->NewFloatArray(len);
CheckException(env);
DCHECK(float_array);
- env->SetFloatArrayRegion(
- float_array, 0, len, reinterpret_cast<const jfloat*>(floats));
+ env->SetFloatArrayRegion(float_array, 0, len,
+ reinterpret_cast<const jfloat*>(floats));
CheckException(env);
return ScopedJavaLocalRef<jfloatArray>(env, float_array);
@@ -120,7 +121,7 @@
BASE_EXPORT ScopedJavaLocalRef<jfloatArray> ToJavaFloatArray(
JNIEnv* env,
- const std::vector<float>& floats) {
+ base::span<const float> floats) {
return ToJavaFloatArray(env, floats.data(), floats.size());
}
@@ -139,15 +140,16 @@
BASE_EXPORT ScopedJavaLocalRef<jdoubleArray> ToJavaDoubleArray(
JNIEnv* env,
- const std::vector<double>& doubles) {
+ base::span<const double> doubles) {
return ToJavaDoubleArray(env, doubles.data(), doubles.size());
}
ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
- JNIEnv* env, const std::vector<std::string>& v) {
+ JNIEnv* env,
+ base::span<const std::string> v) {
ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B");
- jobjectArray joa = env->NewObjectArray(v.size(),
- byte_array_clazz.obj(), NULL);
+ jobjectArray joa =
+ env->NewObjectArray(v.size(), byte_array_clazz.obj(), nullptr);
CheckException(env);
for (size_t i = 0; i < v.size(); ++i) {
@@ -158,10 +160,27 @@
return ScopedJavaLocalRef<jobjectArray>(env, joa);
}
+ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
+ JNIEnv* env,
+ base::span<std::vector<uint8_t>> v) {
+ ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B");
+ jobjectArray joa =
+ env->NewObjectArray(v.size(), byte_array_clazz.obj(), nullptr);
+ CheckException(env);
+
+ for (size_t i = 0; i < v.size(); ++i) {
+ ScopedJavaLocalRef<jbyteArray> byte_array =
+ ToJavaByteArray(env, v[i].data(), v[i].size());
+ env->SetObjectArrayElement(joa, i, byte_array.obj());
+ }
+ return ScopedJavaLocalRef<jobjectArray>(env, joa);
+}
+
ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
- JNIEnv* env, const std::vector<std::string>& v) {
+ JNIEnv* env,
+ base::span<const std::string> v) {
ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String");
- jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL);
+ jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), nullptr);
CheckException(env);
for (size_t i = 0; i < v.size(); ++i) {
@@ -173,12 +192,12 @@
ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStringArray(
JNIEnv* env,
- const std::vector<std::vector<string16>>& vec_outer) {
+ base::span<const std::vector<string16>> vec_outer) {
ScopedJavaLocalRef<jclass> string_array_clazz =
GetClass(env, "[Ljava/lang/String;");
jobjectArray joa =
- env->NewObjectArray(vec_outer.size(), string_array_clazz.obj(), NULL);
+ env->NewObjectArray(vec_outer.size(), string_array_clazz.obj(), nullptr);
CheckException(env);
for (size_t i = 0; i < vec_outer.size(); ++i) {
@@ -191,9 +210,10 @@
}
ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfStrings(
- JNIEnv* env, const std::vector<string16>& v) {
+ JNIEnv* env,
+ base::span<const string16> v) {
ScopedJavaLocalRef<jclass> string_clazz = GetClass(env, "java/lang/String");
- jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), NULL);
+ jobjectArray joa = env->NewObjectArray(v.size(), string_clazz.obj(), nullptr);
CheckException(env);
for (size_t i = 0; i < v.size(); ++i) {
