Revert r201604 "Speculative revert to see if this clears up the h..."

This did not help the builder.

> Speculative revert to see if this clears up the http://build.chromium.org/p/chromium.linux/waterfall?builder=Android%20Tests
> failures. Will reland if this does not do the trick
> 
> Revert 201561 "Android: Implement JavaFloatArrayToFloatVector"
> 
> > Android: Implement JavaFloatArrayToFloatVector
> > 
> > The JNI interface was missing a way to convert float collections from Java to
> > CC, which is needed by Android's Web Speech API to return confidence scores of
> > speech recognition results. Added tests for float and int collections.
> > 
> > TEST=JniArray.JavaFloatArrayToFloatVector and JniArray.JavaIntArrayToIntVector
> > 
> > Review URL: https://chromiumcodereview.appspot.com/15467003
> 
> TBR=janx@chromium.org
> 
> Review URL: https://codereview.chromium.org/15691003

TBR=ananta@chromium.org

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@201615 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 77 insertions, 5 deletions

diff --git a/base/android/jni_array.cc b/base/android/jni_array.cc
index 596914b..bbe00c6 100644
--- a/base/android/jni_array.cc
+++ b/base/android/jni_array.cc
@@ -139,16 +139,29 @@ void JavaByteArrayToByteVector(JNIEnv* env,
 }
 
 void JavaIntArrayToIntVector(JNIEnv* env,
-                             jintArray array,
+                             jintArray int_array,
                              std::vector<int>* out) {
   DCHECK(out);
   out->clear();
-  jsize len = env->GetArrayLength(array);
-  jint* ints = env->GetIntArrayElements(array, NULL);
+  jsize len = env->GetArrayLength(int_array);
+  jint* ints = env->GetIntArrayElements(int_array, NULL);
   for (jsize i = 0; i < len; ++i) {
     out->push_back(static_cast<int>(ints[i]));
   }
-  env->ReleaseIntArrayElements(array, ints, JNI_ABORT);
+  env->ReleaseIntArrayElements(int_array, ints, JNI_ABORT);
+}
+
+void JavaFloatArrayToFloatVector(JNIEnv* env,
+                                 jfloatArray float_array,
+                                 std::vector<float>* out) {
+  DCHECK(out);
+  out->clear();
+  jsize len = env->GetArrayLength(float_array);
+  jfloat* floats = env->GetFloatArrayElements(float_array, NULL);
+  for (jsize i = 0; i < len; ++i) {
+    out->push_back(static_cast<float>(floats[i]));
+  }
+  env->ReleaseFloatArrayElements(float_array, floats, JNI_ABORT);
 }
 
 void JavaArrayOfByteArrayToStringVector(
diff --git a/base/android/jni_array.h b/base/android/jni_array.h
index bb73ea0..668a1ed 100644
--- a/base/android/jni_array.h
+++ b/base/android/jni_array.h
@@ -66,6 +66,12 @@ BASE_EXPORT void JavaIntArrayToIntVector(
     jintArray int_array,
     std::vector<int>* out);
 
+// Replaces the content of |out| with the Java floats in |float_array|.
+BASE_EXPORT void JavaFloatArrayToFloatVector(
+    JNIEnv* env,
+    jfloatArray float_array,
+    std::vector<float>* out);
+
 // Assuming |array| is an byte[][] (array of byte arrays), replaces the
 // content of |out| with the corresponding vector of strings. No UTF-8
 // conversion is performed.
diff --git a/base/android/jni_array_unittest.cc b/base/android/jni_array_unittest.cc
index bc497a8..3ac7855 100644
--- a/base/android/jni_array_unittest.cc
+++ b/base/android/jni_array_unittest.cc
@@ -35,7 +35,7 @@ void CheckLongConversion(
   ASSERT_TRUE(longs.obj());
 
   jsize java_array_len = env->GetArrayLength(longs.obj());
-  ASSERT_EQ(static_cast<int>(len), java_array_len);
+  ASSERT_EQ(static_cast<jsize>(len), java_array_len);
 
   jlong value;
   for (size_t i = 0; i < len; ++i) {
@@ -55,6 +55,59 @@ TEST(JniArray, LongConversions) {
   CheckLongConversion(env, kLongs, kLen, ToJavaLongArray(env, vec));
 }
 
+TEST(JniArray, JavaIntArrayToIntVector) {
+  const int kInts[] = {0, 1, -1};
+  const size_t kLen = arraysize(kInts);
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jintArray> jints(env, env->NewIntArray(kLen));
+  ASSERT_TRUE(jints.obj());
+
+  for (size_t i = 0; i < kLen; ++i) {
+    jint j = static_cast<jint>(kInts[i]);
+    env->SetIntArrayRegion(jints.obj(), i, 1, &j);
+    ASSERT_FALSE(HasException(env));
+  }
+
+  std::vector<int> ints;
+  JavaIntArrayToIntVector(env, jints.obj(), &ints);
+
+  ASSERT_EQ(static_cast<jsize>(ints.size()), env->GetArrayLength(jints.obj()));
+
+  jint value;
+  for (size_t i = 0; i < kLen; ++i) {
+    env->GetIntArrayRegion(jints.obj(), i, 1, &value);
+    ASSERT_EQ(ints[i], value);
+  }
+}
+
+TEST(JniArray, JavaFloatArrayToFloatVector) {
+  const float kFloats[] = {0.0, 0.5, -0.5};
+  const size_t kLen = arraysize(kFloats);
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jfloatArray> jfloats(env, env->NewFloatArray(kLen));
+  ASSERT_TRUE(jfloats.obj());
+
+  for (size_t i = 0; i < kLen; ++i) {
+    jfloat j = static_cast<jfloat>(kFloats[i]);
+    env->SetFloatArrayRegion(jfloats.obj(), i, 1, &j);
+    ASSERT_FALSE(HasException(env));
+  }
+
+  std::vector<float> floats;
+  JavaFloatArrayToFloatVector(env, jfloats.obj(), &floats);
+
+  ASSERT_EQ(static_cast<jsize>(floats.size()),
+      env->GetArrayLength(jfloats.obj()));
+
+  jfloat value;
+  for (size_t i = 0; i < kLen; ++i) {
+    env->GetFloatArrayRegion(jfloats.obj(), i, 1, &value);
+    ASSERT_EQ(floats[i], value);
+  }
+}
+
 TEST(JniArray, JavaArrayOfByteArrayToStringVector) {
   const int kMaxItems = 50;
   JNIEnv* env = AttachCurrentThread();