Implement MediaMetadata artwork in content

content/common/android/media_metadata_android.cc

 // Copyright 2016 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 "content/common/android/media_metadata_android.h"
 
+#include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "content/public/common/media_metadata.h"
 #include "jni/MediaMetadata_jni.h"
 
 namespace content {
 
+namespace {
+
+std::vector<int> GetFlattenedSizeArray(const std::vector<gfx::Size>& sizes) {
+  std::vector<int> flattened_array;
+  flattened_array.reserve(2 * sizes.size());
+  for (const auto& size : sizes) {
+    flattened_array.push_back(size.width());
+    flattened_array.push_back(size.height());
+  }
+  return flattened_array;
+}
+
+}  // anonymous namespace
+
 // static
 base::android::ScopedJavaLocalRef<jobject>
 MediaMetadataAndroid::CreateJavaObject(
     JNIEnv* env, const MediaMetadata& metadata) {
   ScopedJavaLocalRef<jstring> j_title(
       base::android::ConvertUTF16ToJavaString(env, metadata.title));
   ScopedJavaLocalRef<jstring> j_artist(
       base::android::ConvertUTF16ToJavaString(env, metadata.artist));
   ScopedJavaLocalRef<jstring> j_album(
       base::android::ConvertUTF16ToJavaString(env, metadata.album));
 
-  return Java_MediaMetadata_create(
+  ScopedJavaLocalRef<jobject> j_metadata = Java_MediaMetadata_create(
       env, j_title.obj(), j_artist.obj(), j_album.obj());
+
+  for (const auto& artwork : metadata.artwork) {
+    std::string src = artwork.src.spec();
+    base::string16 type = artwork.type.is_null() ?
+        base::string16() : artwork.type.string();
+    ScopedJavaLocalRef<jstring> j_src(
+        base::android::ConvertUTF8ToJavaString(env, src));
+    ScopedJavaLocalRef<jstring> j_type(
+        base::android::ConvertUTF16ToJavaString(env, type));
+    ScopedJavaLocalRef<jintArray> j_sizes(

[DaleCurtis, 2016/06/27 17:49:02]

How many sizes do you expect there to be? Should you instead pass a jintArray
output into GetFlattenedSizeArray(). Or if there are only a couple sizes, why
bother with an array at all? 

[Zhiqiang Zhang (Slow), 2016/06/28 13:57:00]

Actually the array could be of any length. Did you mean letting
GetFlattenedSizeArray() return a jintArray directly (i.e. put the ToJavaIntArray
conversion inside GetFlattenedSizeArray)?

About your concern for parsing, packing and unpacking:
We parse only once from string to vector<gfx::Size>, and then we need to plumb
it to be accessed in chrome Java. So the IPC calls are unavoidable, and
packing/unpacking is for passing sizes through JNI. I think most of them are
unavoidable. Do you have better ideas?

[DaleCurtis, 2016/06/28 19:03:30]

Do you really mean any length or is there a cap? If not there should be :) Do
you have a doc or some more details on exactly what these sizes are for? If you
only parse once it doesn't really matter unless the array is going to be large.
It wasn't clear to me that this is only done once though.

[Zhiqiang Zhang (Slow), 2016/06/28 19:18:36]

The length does not have limit in Blink, but we will shrink the vector if it's
too large in sanitizing.

Sorry I don't have that doc yet. I'll write one tomorrow. Should've done this
earlier to reduce your reviewing effort.

+        base::android::ToJavaIntArray(
+            env, GetFlattenedSizeArray(artwork.sizes)));
+
+    Java_MediaMetadata_createAndAddArtwork(
+        env, j_metadata.obj(), j_src.obj(), j_type.obj(), j_sizes.obj());
+  }
+
+  return j_metadata;
 }
 
 // static
 bool MediaMetadataAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content