Add MediaError.message

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 64 matching lines @@
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/ChromeClient.h"
 #include "platform/Histogram.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/AudioSourceProviderClient.h"
 #include "platform/graphics/GraphicsLayer.h"
+#include "platform/json/JSONValues.h"
 #include "platform/mediastream/MediaStreamDescriptor.h"
 #include "platform/network/NetworkStateNotifier.h"
 #include "platform/network/ParsedContentType.h"
 #include "platform/network/mime/ContentType.h"
 #include "platform/network/mime/MIMETypeFromURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioSourceProvider.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebInbandTextTrack.h"
@@ skipping 119 matching lines @@
                                   Document* document) {
   DocumentElementSetMap& map = DocumentToElementSetMap();
   auto it = map.Find(document);
   DCHECK(it != map.end());
   WeakMediaElementSet* set = it->value;
   set->erase(element);
   if (set->IsEmpty())
     map.erase(it);
 }
 
+std::unique_ptr<JSONObject> BuildSimpleErrorMessage(const String& error) {
+  DEFINE_STATIC_LOCAL(const String, element_error_label, ("MediaElementError"));
+  std::unique_ptr<JSONObject> json_message = JSONObject::Create();
+  std::unique_ptr<JSONArray> errors = JSONArray::Create();
+  errors->PushString(error);
+  json_message->SetArray(element_error_label, std::move(errors));
+  return json_message;
+}
+
+std::unique_ptr<JSONObject> BuildErrorMessage(
+    const std::map<std::string, std::vector<std::string>>& messages) {
+  std::unique_ptr<JSONObject> json_messages = JSONObject::Create();
+  for (const auto& entry : messages) {
+    std::unique_ptr<JSONArray> errors = JSONArray::Create();
+    for (const auto& error : entry.second)
+      errors->PushString(WebString::FromUTF8(error));
+    json_messages->SetArray(WebString::FromUTF8(entry.first),
+                            std::move(errors));
+  }
+
+  return json_messages;
+}
+
 class AudioSourceProviderClientLockScope {
   STACK_ALLOCATED();
 
  public:
   AudioSourceProviderClientLockScope(HTMLMediaElement& element)
       : client_(element.AudioSourceNode()) {
     if (client_)
       client_->lock();
   }
   ~AudioSourceProviderClientLockScope() {
@@ skipping 874 matching lines @@
   LoadResource(WebMediaPlayerSource(WebMediaStream(src_object_)), String());
 }
 
 void HTMLMediaElement::LoadSourceFromAttribute() {
   load_state_ = kLoadingFromSrcAttr;
   const AtomicString& src_value = FastGetAttribute(srcAttr);
 
   // If the src attribute's value is the empty string ... jump down to the
   // failed step below
   if (src_value.IsEmpty()) {
-    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError);
-    BLINK_MEDIA_LOG << "loadSourceFromAttribute(" << (void*)this
+    BLINK_MEDIA_LOG << "LoadSourceFromAttribute(" << (void*)this
                     << "), empty 'src'";
+    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError,
+                       BuildSimpleErrorMessage("Empty src attribute"));
     return;
   }
 
   KURL media_url = GetDocument().CompleteURL(src_value);
   if (!IsSafeToLoadURL(media_url, kComplain)) {
-    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError);
+    MediaLoadingFailed(
+        WebMediaPlayer::kNetworkStateFormatError,
+        BuildSimpleErrorMessage("Media load rejected by URL safety check"));
     return;
   }
 
   // No type is available when the url comes from the 'src' attribute so
   // MediaPlayer will have to pick a media engine based on the file extension.
   LoadResource(WebMediaPlayerSource(WebURL(media_url)), String());
 }
 
 void HTMLMediaElement::LoadNextSourceChild() {
   String content_type;
@@ skipping 16 matching lines @@
   KURL url;
   if (source.IsURL()) {
     url = source.GetAsURL();
     DCHECK(IsSafeToLoadURL(url, kComplain));
     BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ", "
                     << UrlForLoggingMedia(url) << ", " << content_type << ")";
   }
 
   LocalFrame* frame = GetDocument().GetFrame();
   if (!frame) {
-    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError);
+    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError,
+                       BuildSimpleErrorMessage(
+                           "Resource load failure: document has no frame"));
     return;
   }
 
   // The resource fetch algorithm
   SetNetworkState(kNetworkLoading);
 
   // Set m_currentSrc *before* changing to the cache url, the fact that we are
   // loading from the app cache is an internal detail not exposed through the
   // media element API.
   current_src_ = url;
@@ skipping 37 matching lines @@
     // including MediaSource blob URLs.
     if (!source.IsMediaStream() && !url.ProtocolIs("blob") &&
         EffectivePreloadType() == WebMediaPlayer::kPreloadNone) {
       BLINK_MEDIA_LOG << "loadResource(" << (void*)this
                       << ") : Delaying load because preload == 'none'";
       DeferLoad();
     } else {
       StartPlayerLoad();
     }
   } else {
-    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError);
+    MediaLoadingFailed(
+        WebMediaPlayer::kNetworkStateFormatError,
+        BuildSimpleErrorMessage(attempt_load
+                                    ? "Unable to load URL due to content type"
+                                    : "Unable to attach MediaSource"));
   }
 
   // If there is no poster to display, allow the media engine to render video
   // frames as soon as they are available.
   UpdateDisplayState();
 
   if (GetLayoutObject())
     GetLayoutObject()->UpdateFromElement();
 }
 
@@ skipping 25 matching lines @@
       request_url.SetPass(String());
 
     KURL kurl(kParsedURLString, request_url);
     source = WebMediaPlayerSource(WebURL(kurl));
   }
 
   LocalFrame* frame = GetDocument().GetFrame();
   // TODO(srirama.m): Figure out how frame can be null when
   // coming from executeDeferredLoad()
   if (!frame) {
-    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError);
+    MediaLoadingFailed(
+        WebMediaPlayer::kNetworkStateFormatError,
+        BuildSimpleErrorMessage("Player load failure: document has no frame"));
     return;
   }
 
   web_media_player_ =
       frame->Loader().Client()->CreateWebMediaPlayer(*this, source, this);
   if (!web_media_player_) {
-    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError);
+    MediaLoadingFailed(WebMediaPlayer::kNetworkStateFormatError,
+                       BuildSimpleErrorMessage(
+                           "Player load failure: error creating media player"));
     return;
   }
 
   if (GetLayoutObject())
     GetLayoutObject()->SetShouldDoFullPaintInvalidation();
   // Make sure if we create/re-create the WebMediaPlayer that we update our
   // wrapper.
   audio_source_provider_.Wrap(web_media_player_->GetAudioSourceProvider());
   web_media_player_->SetVolume(EffectiveMediaVolume());
 
@@ skipping 222 matching lines @@
   // 6.18 - Set the element's delaying-the-load-event flag to false. This stops
   // delaying the load event.
   SetShouldDelayLoadEvent(false);
 
   UpdateDisplayState();
 
   if (GetLayoutObject())
     GetLayoutObject()->UpdateFromElement();
 }
 
-void HTMLMediaElement::NoneSupported() {
-  BLINK_MEDIA_LOG << "noneSupported(" << (void*)this << ")";
+void HTMLMediaElement::NoneSupported(std::unique_ptr<JSONObject> messages) {
+  BLINK_MEDIA_LOG << "NoneSupported(" << (void*)this << ", messages='"
+                  << messages->ToJSONString() << "')";
 
   StopPeriodicTimers();
   load_state_ = kWaitingForSource;
   current_source_node_ = nullptr;
 
   // 4.8.12.5
   // The dedicated media source failure steps are the following steps:
 
   // 1 - Set the error attribute to a new MediaError object whose code attribute
   // is set to MEDIA_ERR_SRC_NOT_SUPPORTED.
-  error_ = MediaError::Create(MediaError::kMediaErrSrcNotSupported);
+  error_ =
+      MediaError::Create(MediaError::kMediaErrSrcNotSupported, messages.get());
 
   // 2 - Forget the media element's media-resource-specific text tracks.
   ForgetResourceSpecificTracks();
 
   // 3 - Set the element's networkState attribute to the NETWORK_NO_SOURCE
   // value.
   SetNetworkState(kNetworkNoSource);
 
   // 4 - Set the element's show poster flag to true.
   UpdateDisplayState();
@@ skipping 48 matching lines @@
   for (HTMLSourceElement* source =
            Traversal<HTMLSourceElement>::FirstChild(*this);
        source; source = Traversal<HTMLSourceElement>::NextSibling(*source))
     source->CancelPendingErrorEvent();
 }
 
 void HTMLMediaElement::NetworkStateChanged() {
   SetNetworkState(GetWebMediaPlayer()->GetNetworkState());
 }
 
-void HTMLMediaElement::MediaLoadingFailed(WebMediaPlayer::NetworkState error) {
+void HTMLMediaElement::MediaLoadingFailed(
+    WebMediaPlayer::NetworkState error,
+    std::unique_ptr<JSONObject> messages) {
+  BLINK_MEDIA_LOG << "MediaLoadingFailed(" << (void*)this << ", "
+                  << static_cast<int>(error) << ", messages='"
+                  << messages->ToJSONString() << "')";
+
   StopPeriodicTimers();
 
   // If we failed while trying to load a <source> element, the movie was never
   // parsed, and there are more <source> children, schedule the next one
   if (ready_state_ < kHaveMetadata &&
       load_state_ == kLoadingFromSourceElement) {
     // resource selection algorithm
     // Step 9.Otherwise.9 - Failed with elements: Queue a task, using the DOM
     // manipulation task source, to fire a simple event named error at the
     // candidate element.
@@ skipping 19 matching lines @@
       BLINK_MEDIA_LOG << "mediaLoadingFailed(" << (void*)this
                       << ") - no more <source> elements, waiting";
       WaitForSourceChange();
     }
 
     return;
   }
 
   if (error == WebMediaPlayer::kNetworkStateNetworkError &&
       ready_state_ >= kHaveMetadata) {
-    MediaEngineError(MediaError::Create(MediaError::kMediaErrNetwork));
+    MediaEngineError(
+        MediaError::Create(MediaError::kMediaErrNetwork, messages.get()));
   } else if (error == WebMediaPlayer::kNetworkStateDecodeError) {
-    MediaEngineError(MediaError::Create(MediaError::kMediaErrDecode));
+    MediaEngineError(
+        MediaError::Create(MediaError::kMediaErrDecode, messages.get()));
   } else if ((error == WebMediaPlayer::kNetworkStateFormatError ||
               error == WebMediaPlayer::kNetworkStateNetworkError) &&
              load_state_ == kLoadingFromSrcAttr) {
-    NoneSupported();
+    if (!messages->size()) {
+      // Generate a more meaningful error message to differentiate the two types
+      // of MEDIA_SRC_ERR_NOT_SUPPORTED.
+      NoneSupported(BuildSimpleErrorMessage(
+          error == WebMediaPlayer::kNetworkStateFormatError ? "Format error"
+                                                            : "Network error"));
+    } else {
+      NoneSupported(std::move(messages));
+    }
   }
 
   UpdateDisplayState();
 }
 
 void HTMLMediaElement::SetNetworkState(WebMediaPlayer::NetworkState state) {
   BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ", "
                   << static_cast<int>(state) << ") - current state is "
                   << static_cast<int>(network_state_);
 
   if (state == WebMediaPlayer::kNetworkStateEmpty) {
     // Just update the cached state and leave, we can't do anything.
     SetNetworkState(kNetworkEmpty);
     return;
   }
 
   if (state == WebMediaPlayer::kNetworkStateFormatError ||
       state == WebMediaPlayer::kNetworkStateNetworkError ||
       state == WebMediaPlayer::kNetworkStateDecodeError) {
-    MediaLoadingFailed(state);
+    MediaLoadingFailed(
+        state, BuildErrorMessage(web_media_player_->GetErrorMessages()));
     return;
   }
 
   if (state == WebMediaPlayer::kNetworkStateIdle) {
     if (network_state_ > kNetworkIdle) {
       ChangeNetworkStateFromLoadingToIdle();
       SetShouldDelayLoadEvent(false);
     } else {
       SetNetworkState(kNetworkIdle);
     }
@@ skipping 2593 matching lines @@
       kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::ViewportFillDebouncerTimerFired(TimerBase*) {
   mostly_filling_viewport_ = true;
   if (web_media_player_)
     web_media_player_->BecameDominantVisibleContent(mostly_filling_viewport_);
 }
 
 }  // namespace blink