android: Add ToJavaByteArray variant for vector<uint8_t>.

Add ToJavaByteArray for const std::vector<uint8_t>&.

Update file to no longer use deprecated uint8, int64.

Review URL: https://codereview.chromium.org/1411353003

Cr-Commit-Position: refs/heads/master@{#357550}

3 files changed, 72 insertions, 51 deletions

diff --git a/base/android/jni_array.cc b/base/android/jni_array.cc
index e419b34..e4f3f0b 100644
--- a/base/android/jni_array.cc
+++ b/base/android/jni_array.cc
@@ -25,8 +25,9 @@ size_t SafeGetArrayLength(JNIEnv* env, JavaArrayType jarray) {
 
 }  // namespace
 
-ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
-    JNIEnv* env, const uint8* bytes, size_t len) {
+ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(JNIEnv* env,
+                                               const uint8_t* bytes,
+                                               size_t len) {
   jbyteArray byte_array = env->NewByteArray(len);
   CheckException(env);
   DCHECK(byte_array);
@@ -38,6 +39,12 @@ ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
   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<jintArray> ToJavaIntArray(
     JNIEnv* env, const int* ints, size_t len) {
   jintArray int_array = env->NewIntArray(len);
@@ -56,8 +63,9 @@ ScopedJavaLocalRef<jintArray> ToJavaIntArray(
   return ToJavaIntArray(env, ints.data(), ints.size());
 }
 
-ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
-    JNIEnv* env, const int64* longs, size_t len) {
+ScopedJavaLocalRef<jlongArray> ToJavaLongArray(JNIEnv* env,
+                                               const int64_t* longs,
+                                               size_t len) {
   jlongArray long_array = env->NewLongArray(len);
   CheckException(env);
   DCHECK(long_array);
@@ -69,9 +77,10 @@ ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
   return ScopedJavaLocalRef<jlongArray>(env, long_array);
 }
 
-// Returns a new Java long array converted from the given int64 array.
+// Returns a new Java long array converted from the given int64_t array.
 BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
-    JNIEnv* env, const std::vector<int64>& longs) {
+    JNIEnv* env,
+    const std::vector<int64_t>& longs) {
   return ToJavaLongArray(env, longs.data(), longs.size());
 }
 
@@ -83,8 +92,8 @@ ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
   CheckException(env);
 
   for (size_t i = 0; i < v.size(); ++i) {
-    ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(env,
-        reinterpret_cast<const uint8*>(v[i].data()), v[i].length());
+    ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(
+        env, reinterpret_cast<const uint8_t*>(v[i].data()), v[i].length());
     env->SetObjectArrayElement(joa, i, byte_array.obj());
   }
   return ScopedJavaLocalRef<jobjectArray>(env, joa);
@@ -150,7 +159,7 @@ void AppendJavaStringArrayToStringVector(JNIEnv* env,
 
 void AppendJavaByteArrayToByteVector(JNIEnv* env,
                                      jbyteArray byte_array,
-                                     std::vector<uint8>* out) {
+                                     std::vector<uint8_t>* out) {
   DCHECK(out);
   if (!byte_array)
     return;
@@ -165,7 +174,7 @@ void AppendJavaByteArrayToByteVector(JNIEnv* env,
 
 void JavaByteArrayToByteVector(JNIEnv* env,
                                jbyteArray byte_array,
-                               std::vector<uint8>* out) {
+                               std::vector<uint8_t>* out) {
   DCHECK(out);
   DCHECK(byte_array);
   out->clear();
@@ -187,7 +196,7 @@ void JavaIntArrayToIntVector(JNIEnv* env,
 
 void JavaLongArrayToInt64Vector(JNIEnv* env,
                                 jlongArray long_array,
-                                std::vector<int64>* out) {
+                                std::vector<int64_t>* out) {
   DCHECK(out);
   std::vector<jlong> temp;
   JavaLongArrayToLongVector(env, long_array, &temp);
diff --git a/base/android/jni_array.h b/base/android/jni_array.h
index 658239d..86e63c5 100644
--- a/base/android/jni_array.h
+++ b/base/android/jni_array.h
@@ -6,19 +6,24 @@
 #define BASE_ANDROID_JNI_ARRAY_H_
 
 #include <jni.h>
+#include <stdint.h>
 #include <string>
 #include <vector>
 
 #include "base/android/scoped_java_ref.h"
-#include "base/basictypes.h"
 #include "base/strings/string16.h"
 
 namespace base {
 namespace android {
 
 // Returns a new Java byte array converted from the given bytes array.
+BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(JNIEnv* env,
+                                                           const uint8_t* bytes,
+                                                           size_t len);
+
 BASE_EXPORT ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
-    JNIEnv* env, const uint8* bytes, size_t len);
+    JNIEnv* env,
+    const std::vector<uint8_t>& bytes);
 
 // Returns a new Java int array converted from the given int array.
 BASE_EXPORT ScopedJavaLocalRef<jintArray> ToJavaIntArray(
@@ -28,11 +33,13 @@ BASE_EXPORT ScopedJavaLocalRef<jintArray> ToJavaIntArray(
     JNIEnv* env, const std::vector<int>& ints);
 
 // Returns a new Java long array converted from the given int64 array.
-BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
-    JNIEnv* env, const int64* longs, size_t len);
+BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(JNIEnv* env,
+                                                           const int64_t* longs,
+                                                           size_t len);
 
 BASE_EXPORT ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
-    JNIEnv* env, const std::vector<int64>& longs);
+    JNIEnv* env,
+    const std::vector<int64_t>& longs);
 
 // Returns a array of Java byte array converted from |v|.
 BASE_EXPORT ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
@@ -56,16 +63,14 @@ BASE_EXPORT void AppendJavaStringArrayToStringVector(
     std::vector<std::string>* out);
 
 // Appends the Java bytes in |bytes_array| onto the end of |out|.
-BASE_EXPORT void AppendJavaByteArrayToByteVector(
-    JNIEnv* env,
-    jbyteArray byte_array,
-    std::vector<uint8>* out);
+BASE_EXPORT void AppendJavaByteArrayToByteVector(JNIEnv* env,
+                                                 jbyteArray byte_array,
+                                                 std::vector<uint8_t>* out);
 
 // Replaces the content of |out| with the Java bytes in |bytes_array|.
-BASE_EXPORT void JavaByteArrayToByteVector(
-    JNIEnv* env,
-    jbyteArray byte_array,
-    std::vector<uint8>* out);
+BASE_EXPORT void JavaByteArrayToByteVector(JNIEnv* env,
+                                           jbyteArray byte_array,
+                                           std::vector<uint8_t>* out);
 
 // Replaces the content of |out| with the Java ints in |int_array|.
 BASE_EXPORT void JavaIntArrayToIntVector(
@@ -74,10 +79,9 @@ BASE_EXPORT void JavaIntArrayToIntVector(
     std::vector<int>* out);
 
 // Replaces the content of |out| with the Java longs in |long_array|.
-BASE_EXPORT void JavaLongArrayToInt64Vector(
-    JNIEnv* env,
-    jlongArray long_array,
-    std::vector<int64>* out);
+BASE_EXPORT void JavaLongArrayToInt64Vector(JNIEnv* env,
+                                            jlongArray long_array,
+                                            std::vector<int64_t>* out);
 
 // Replaces the content of |out| with the Java longs in |long_array|.
 BASE_EXPORT void JavaLongArrayToLongVector(
diff --git a/base/android/jni_array_unittest.cc b/base/android/jni_array_unittest.cc
index e9ae3fc..f81014e 100644
--- a/base/android/jni_array_unittest.cc
+++ b/base/android/jni_array_unittest.cc
@@ -12,22 +12,31 @@ namespace base {
 namespace android {
 
 TEST(JniArray, BasicConversions) {
-  const uint8 kBytes[] = { 0, 1, 2, 3 };
+  const uint8_t kBytes[] = {0, 1, 2, 3};
   const size_t kLen = arraysize(kBytes);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> bytes = ToJavaByteArray(env, kBytes, kLen);
   ASSERT_TRUE(bytes.obj());
 
-  std::vector<uint8> vec(5);
-  JavaByteArrayToByteVector(env, bytes.obj(), &vec);
-  EXPECT_EQ(4U, vec.size());
-  std::vector<uint8> expected_vec(kBytes, kBytes + kLen);
-  EXPECT_EQ(expected_vec, vec);
-
-  AppendJavaByteArrayToByteVector(env, bytes.obj(), &vec);
-  EXPECT_EQ(8U, vec.size());
+  std::vector<uint8_t> inputVector(kBytes, kBytes + kLen);
+  ScopedJavaLocalRef<jbyteArray> bytesFromVector =
+      ToJavaByteArray(env, inputVector);
+  ASSERT_TRUE(bytesFromVector.obj());
+
+  std::vector<uint8_t> vectorFromBytes(5);
+  std::vector<uint8_t> vectorFromVector(5);
+  JavaByteArrayToByteVector(env, bytes.obj(), &vectorFromBytes);
+  JavaByteArrayToByteVector(env, bytesFromVector.obj(), &vectorFromVector);
+  EXPECT_EQ(4U, vectorFromBytes.size());
+  EXPECT_EQ(4U, vectorFromVector.size());
+  std::vector<uint8_t> expected_vec(kBytes, kBytes + kLen);
+  EXPECT_EQ(expected_vec, vectorFromBytes);
+  EXPECT_EQ(expected_vec, vectorFromVector);
+
+  AppendJavaByteArrayToByteVector(env, bytes.obj(), &vectorFromBytes);
+  EXPECT_EQ(8U, vectorFromBytes.size());
   expected_vec.insert(expected_vec.end(), kBytes, kBytes + kLen);
-  EXPECT_EQ(expected_vec, vec);
+  EXPECT_EQ(expected_vec, vectorFromBytes);
 }
 
 void CheckIntConversion(
@@ -58,11 +67,10 @@ TEST(JniArray, IntConversions) {
   CheckIntConversion(env, kInts, kLen, ToJavaIntArray(env, vec));
 }
 
-void CheckLongConversion(
-    JNIEnv* env,
-    const int64* long_array,
-    const size_t len,
-    const ScopedJavaLocalRef<jlongArray>& longs) {
+void CheckLongConversion(JNIEnv* env,
+                         const int64_t* long_array,
+                         const size_t len,
+                         const ScopedJavaLocalRef<jlongArray>& longs) {
   ASSERT_TRUE(longs.obj());
 
   jsize java_array_len = env->GetArrayLength(longs.obj());
@@ -76,13 +84,13 @@ void CheckLongConversion(
 }
 
 TEST(JniArray, LongConversions) {
-  const int64 kLongs[] = { 0, 1, -1, kint64min, kint64max};
+  const int64_t kLongs[] = {0, 1, -1, kint64min, kint64max};
   const size_t kLen = arraysize(kLongs);
 
   JNIEnv* env = AttachCurrentThread();
   CheckLongConversion(env, kLongs, kLen, ToJavaLongArray(env, kLongs, kLen));
 
-  const std::vector<int64> vec(kLongs, kLongs + kLen);
+  const std::vector<int64_t> vec(kLongs, kLongs + kLen);
   CheckLongConversion(env, kLongs, kLen, ToJavaLongArray(env, vec));
 }
 
@@ -120,7 +128,7 @@ TEST(JniArray, JavaIntArrayToIntVector) {
 }
 
 TEST(JniArray, JavaLongArrayToInt64Vector) {
-  const int64 kInt64s[] = {0LL, 1LL, -1LL};
+  const int64_t kInt64s[] = {0LL, 1LL, -1LL};
   const size_t kLen = arraysize(kInt64s);
 
   JNIEnv* env = AttachCurrentThread();
@@ -133,7 +141,7 @@ TEST(JniArray, JavaLongArrayToInt64Vector) {
     ASSERT_FALSE(HasException(env));
   }
 
-  std::vector<int64> int64s;
+  std::vector<int64_t> int64s;
   JavaLongArrayToInt64Vector(env, jlongs.obj(), &int64s);
 
   ASSERT_EQ(static_cast<jsize>(int64s.size()),
@@ -148,7 +156,7 @@ TEST(JniArray, JavaLongArrayToInt64Vector) {
 }
 
 TEST(JniArray, JavaLongArrayToLongVector) {
-  const int64 kInt64s[] = {0LL, 1LL, -1LL};
+  const int64_t kInt64s[] = {0LL, 1LL, -1LL};
   const size_t kLen = arraysize(kInt64s);
 
   JNIEnv* env = AttachCurrentThread();
@@ -217,9 +225,9 @@ TEST(JniArray, JavaArrayOfByteArrayToStringVector) {
   char text[16];
   for (int i = 0; i < kMaxItems; ++i) {
     snprintf(text, sizeof text, "%d", i);
-    ScopedJavaLocalRef<jbyteArray> byte_array = ToJavaByteArray(
-        env, reinterpret_cast<uint8*>(text),
-        static_cast<size_t>(strlen(text)));
+    ScopedJavaLocalRef<jbyteArray> byte_array =
+        ToJavaByteArray(env, reinterpret_cast<uint8_t*>(text),
+                        static_cast<size_t>(strlen(text)));
     ASSERT_TRUE(byte_array.obj());
 
     env->SetObjectArrayElement(array.obj(), i, byte_array.obj());