Implement MediaMetadata artwork in content

content/common/android/media_metadata_android.cc

Index: content/common/android/media_metadata_android.cc
diff --git a/content/common/android/media_metadata_android.cc b/content/common/android/media_metadata_android.cc
index 0bd1563175891fc221764f984e5f1b048c62ab0f..08d1f9bdfc9b4f32315d1a20c3cc6c6e0e22a436 100644
--- a/content/common/android/media_metadata_android.cc
+++ b/content/common/android/media_metadata_android.cc
@@ -4,12 +4,27 @@
 
 #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(
@@ -21,8 +36,26 @@ MediaMetadataAndroid::CreateJavaObject(
   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