Implement WebStorage API methods

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"
 
 namespace base {
 namespace android {
 
 ScopedJavaLocalRef<jbyteArray> ToJavaByteArray(
     JNIEnv* env, const uint8* bytes, size_t len) {
   jbyteArray byte_array = env->NewByteArray(len);
   CheckException(env);
   DCHECK(byte_array);
 
   jbyte* elements = env->GetByteArrayElements(byte_array, NULL);
   memcpy(elements, bytes, len);
   env->ReleaseByteArrayElements(byte_array, elements, 0);
   CheckException(env);
 
   return ScopedJavaLocalRef<jbyteArray>(env, byte_array);
 }
 
+ScopedJavaLocalRef<jlongArray> ToJavaLongArray(
+    JNIEnv* env, const int64* longs, size_t len) {

[mkosiba (inactive), 2013/02/20 12:21:38]

I know the function above uses a raw C-style array but std::vector is just as
efficient, guaranteed to take up a continuous block of memory (so memcpy-ing it
is OK) and you don't risk mis-specifying the len.

Also, it seems all ToJavaLongArray callsites use a vector. You probably should
add a wrapper that takes in a vector and calls this method to do the actual
work.

[boliu, 2013/02/20 20:14:16]

Overloaded the method with a vector version and updated the test to reflect
that.

+  jlongArray long_array = env->NewLongArray(len);
+  CheckException(env);
+  DCHECK(long_array);
+
+  jlong* elements = env->GetLongArrayElements(long_array, NULL);
+  memcpy(elements, longs, len * sizeof(*longs));

[mkosiba (inactive), 2013/02/20 12:21:38]

I can't remember what the exact issue was but one of the C++ books I read
recommended using the type (int64) rather than the variable in this case. 

I'd say that it's OK to hardcode the type since the method does explicitly deal
with longs (aka int64s) so the chances that you change the type of *longs and
forget to update the code are low.

[boliu, 2013/02/20 20:14:16]

I remember in one of the effective c++ books, the recommendation is the exact
opposite, because then the sizeof and the type of the variable will not get out
of sync.
I don't really care much either way and I see sizeof with both styles under
base/. So...I'll do whatever joth says? If he doesn't care, I'll use the type.

+  env->ReleaseLongArrayElements(long_array, elements, 0);
+  CheckException(env);
+
+  return ScopedJavaLocalRef<jlongArray>(env, long_array);
+}
+
 ScopedJavaLocalRef<jobjectArray> ToJavaArrayOfByteArray(
     JNIEnv* env, const std::vector<std::string>& v) {
   ScopedJavaLocalRef<jclass> byte_array_clazz = GetClass(env, "[B");
   jobjectArray joa = env->NewObjectArray(v.size(),
                                          byte_array_clazz.obj(), NULL);
   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());
@@ skipping 106 matching lines @@
         env->GetObjectArrayElement(array, i));
     jsize bytes_len = env->GetArrayLength(bytes_array);
     jbyte* bytes = env->GetByteArrayElements(bytes_array, NULL);
     (*out)[i].assign(reinterpret_cast<const char*>(bytes), bytes_len);
     env->ReleaseByteArrayElements(bytes_array, bytes, JNI_ABORT);
   }
 }
 
 }  // namespace android
 }  // namespace base