Media Session: use dictionary instead of an interface for MediaImage.

third_party/WebKit/Source/modules/mediasession/MediaMetadata.cpp

 // Copyright 2015 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 "modules/mediasession/MediaMetadata.h"
 
-#include "core/dom/ExecutionContext.h"
 #include "modules/mediasession/MediaImage.h"
 #include "modules/mediasession/MediaMetadataInit.h"
 #include "modules/mediasession/MediaSession.h"
 
 namespace blink {
 
 // static
-MediaMetadata* MediaMetadata::create(ExecutionContext* context,
-                                     const MediaMetadataInit& metadata) {
-  return new MediaMetadata(context, metadata);
+MediaMetadata* MediaMetadata::create(ScriptState* scriptState,
+                                     const MediaMetadataInit& metadata,
+                                     ExceptionState& exceptionState) {
+  return new MediaMetadata(scriptState, metadata, exceptionState);
 }
 
-MediaMetadata::MediaMetadata(ExecutionContext* context,
-                             const MediaMetadataInit& metadata)
+MediaMetadata::MediaMetadata(ScriptState* scriptState,
+                             const MediaMetadataInit& metadata,
+                             ExceptionState& exceptionState)
     : m_notifySessionTimer(this, &MediaMetadata::notifySessionTimerFired) {
   m_title = metadata.title();
   m_artist = metadata.artist();
   m_album = metadata.album();
-  for (const auto& image : metadata.artwork())
-    m_artwork.append(MediaImage::create(context, image));
+  setArtworkInternal(scriptState, metadata.artwork(), exceptionState);
 }
 
 String MediaMetadata::title() const {
   return m_title;
 }
 
 String MediaMetadata::artist() const {
   return m_artist;
 }
 
 String MediaMetadata::album() const {
   return m_album;
 }
 
-const HeapVector<Member<MediaImage>>& MediaMetadata::artwork() const {
+const HeapVector<MediaImage>& MediaMetadata::artwork() const {
   return m_artwork;
 }
 
+Vector<v8::Local<v8::Value>> MediaMetadata::artwork(
+    ScriptState* scriptState) const {
+  Vector<v8::Local<v8::Value>> result(m_artwork.size());

[Zhiqiang Zhang (Slow), 2017/01/05 16:03:08]

Why not freeze them in the ctor?

[Zhiqiang Zhang (Slow), 2017/01/05 16:06:40]

I see it's following the pattern of Notification.cpp :) Please ignore

[mlamouri (slow - plz ping), 2017/01/05 19:28:22]

Ack :)

+
+  for (size_t i = 0; i < m_artwork.size(); ++i) {
+    result[i] =
+        freezeV8Object(toV8(m_artwork[i], scriptState), scriptState->isolate());
+  }
+
+  return result;
+}
+
 void MediaMetadata::setTitle(const String& title) {
   m_title = title;
   notifySessionAsync();
 }
 
 void MediaMetadata::setArtist(const String& artist) {
   m_artist = artist;
   notifySessionAsync();
 }
 
 void MediaMetadata::setAlbum(const String& album) {
   m_album = album;
   notifySessionAsync();
 }
 
-void MediaMetadata::setArtwork(const HeapVector<Member<MediaImage>>& artwork) {
-  m_artwork = artwork;
+void MediaMetadata::setArtwork(ScriptState* scriptState,
+                               const HeapVector<MediaImage>& artwork,
+                               ExceptionState& exceptionState) {
+  setArtworkInternal(scriptState, artwork, exceptionState);
   notifySessionAsync();
 }
 
 void MediaMetadata::setSession(MediaSession* session) {
   m_session = session;
 }
 
 void MediaMetadata::notifySessionAsync() {
   if (!m_session || m_notifySessionTimer.isActive())
     return;
   m_notifySessionTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void MediaMetadata::notifySessionTimerFired(TimerBase*) {
   if (!m_session)
     return;
   m_session->onMetadataChanged();
 }
 
+void MediaMetadata::setArtworkInternal(ScriptState* scriptState,
+                                       const HeapVector<MediaImage>& artwork,
+                                       ExceptionState& exceptionState) {
+  HeapVector<MediaImage> processedArtwork(artwork);
+
+  for (MediaImage& image : processedArtwork) {
+    KURL url = scriptState->getExecutionContext()->completeURL(image.src());
+    if (!url.isValid()) {
+      exceptionState.throwTypeError("'" + image.src() +

[Zhiqiang Zhang (Slow), 2017/01/05 16:03:08]

Should this be URIError? I currently use it in the spec PR.

[mlamouri (slow - plz ping), 2017/01/05 19:28:22]

TypeError is the one we use when something doesn't match the expected type. I
think it's fair to use TypeError and it matches some other specs (like
Presentation API). Any reason why you used URIError?

(I will not block the CL on your reply and we can always change the code/spec
after the fact, it's a one-liner :))

+                                    "' can't be resolved to a valid URL.");
+      return;
+    }
+    image.setSrc(url);
+  }
+
+  DCHECK(!exceptionState.hadException());
+  m_artwork.swap(processedArtwork);
+}
+
 DEFINE_TRACE(MediaMetadata) {
   visitor->trace(m_artwork);
   visitor->trace(m_session);
 }
 
 }  // namespace blink