[Contextual Search] Add support for crushed sprites and animate the search provider icon

base/android/jni_array_unittest.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/scoped_java_ref.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 68 matching lines @@
   const int64 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);
   CheckLongConversion(env, kLongs, kLen, ToJavaLongArray(env, vec));
 }
 
+void CheckIntArrayConversion(JNIEnv* env,
+                             ScopedJavaLocalRef<jintArray> jints,
+                             std::vector<int> int_vector,
+                             const size_t len) {
+  jint value;
+  for (size_t i = 0; i < len; ++i) {
+    env->GetIntArrayRegion(jints.obj(), i, 1, &value);
+    ASSERT_EQ(int_vector[i], value);
+  }
+}
+
 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);
-  }
+  CheckIntArrayConversion(env, jints, ints, kLen);
 }
 
 TEST(JniArray, JavaLongArrayToInt64Vector) {
   const int64 kInt64s[] = {0LL, 1LL, -1LL};
   const size_t kLen = arraysize(kInt64s);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jlongArray> jlongs(env, env->NewLongArray(kLen));
   ASSERT_TRUE(jlongs.obj());
 
@@ skipping 100 matching lines @@
   std::vector<std::string> vec;
   JavaArrayOfByteArrayToStringVector(env, array.obj(), &vec);
 
   EXPECT_EQ(static_cast<size_t>(kMaxItems), vec.size());
   for (int i = 0; i < kMaxItems; ++i) {
     snprintf(text, sizeof text, "%d", i);
     EXPECT_STREQ(text, vec[i].c_str());
   }
 }
 
+TEST(JniArray, JavaArrayOfIntArrayToIntVector) {
+  const size_t kNumItems = 3;
+  JNIEnv* env = AttachCurrentThread();
+
+  // Create an int[][] object.
+  ScopedJavaLocalRef<jclass> int_array_clazz(env, env->FindClass("[I"));
+  ASSERT_TRUE(int_array_clazz.obj());
+
+  ScopedJavaLocalRef<jobjectArray> array(
+      env, env->NewObjectArray(kNumItems, int_array_clazz.obj(), NULL));

[David Trainor- moved to gerrit, 2015/10/15 21:04:56]

nullptr

[Theresa, 2015/10/24 00:06:44]

Done.

+  ASSERT_TRUE(array.obj());
+
+  // Populate int[][] object.
+  const int kInts0[] = {0, 1, -1, kint32min, kint32max};
+  const size_t kLen0 = arraysize(kInts0);
+  ScopedJavaLocalRef<jintArray> int_array0 = ToJavaIntArray(env, kInts0, kLen0);
+  env->SetObjectArrayElement(array.obj(), 0, int_array0.obj());
+
+  const int kInts1[] = {3, 4, 5};
+  const size_t kLen1 = arraysize(kInts1);
+  ScopedJavaLocalRef<jintArray> int_array1 = ToJavaIntArray(env, kInts1, kLen1);
+  env->SetObjectArrayElement(array.obj(), 1, int_array1.obj());
+
+  const int kInts2[] = {16};
+  const size_t kLen2 = arraysize(kInts2);
+  ScopedJavaLocalRef<jintArray> int_array2 = ToJavaIntArray(env, kInts2, kLen2);
+  env->SetObjectArrayElement(array.obj(), 2, int_array2.obj());
+
+  // Convert to std::vector<std::vector<int>>, check the content.

[David Trainor- moved to gerrit, 2015/10/15 21:04:56]

Odd question, do we want to handle empty/null arrays within the 2D array?

[Theresa, 2015/10/24 00:06:44]

If we have an animation that displays the same image for a few frames then we
could have empty array within the 2D array. It's not needed for this patch but
wouldn't hurt to test that it works. I think null arrays within the 2D array
shouldn't be supported.

I added an entry for an empty array to this test and it still passes. I'll keep
that case in mind while writing other tests (and probably manually test as
well).

+  std::vector<std::vector<int>> out;
+  JavaArrayOfIntArrayToIntVector(env, array.obj(), &out);
+
+  EXPECT_EQ(kNumItems, out.size());
+  CheckIntArrayConversion(env, int_array0, out[0], kLen0);
+  CheckIntArrayConversion(env, int_array1, out[1], kLen1);
+  CheckIntArrayConversion(env, int_array2, out[2], kLen2);
+}
+
 }  // namespace android
 }  // namespace base