Add MediaError.message

content/browser/media/media_browsertest.cc

 // Copyright (c) 2013 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/browser/media/media_browsertest.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
 #include "media/media_features.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "url/url_util.h"
 
 namespace content {
 
 // TODO(sandersd): Change the tests to use a more unique message.
 // See http://crbug.com/592067
 
 // Common test results.
 const char MediaBrowserTest::kFailed[] = "FAILED";
 
 // Upper case event name set by Utils.installTitleEventHandler().
@@ skipping 33 matching lines @@
                                       const std::string& expected_title) {
   VLOG(0) << "Running test URL: " << gurl;
   TitleWatcher title_watcher(shell()->web_contents(),
                              base::ASCIIToUTF16(expected_title));
   AddTitlesToAwait(&title_watcher);
   NavigateToURL(shell(), gurl);
   base::string16 result = title_watcher.WaitAndGetTitle();
   return base::UTF16ToASCII(result);
 }
 
+std::string MediaBrowserTest::EncodeErrorMessage(

[mlamouri (slow - plz ping), 2017/04/12 15:56:41]

Where is this called?

[wolenetz, 2017/04/13 23:59:10]

Oops! :) Especially with newlines in the message, I'll correctly call this now
from ::RunErrorMessageTest() like I was originally intending.

Done.

+    const std::string& original_message) {
+  url::RawCanonOutputT<char> buffer;
+  url::EncodeURIComponent(original_message.data(), original_message.size(),
+                          &buffer);
+  return std::string(buffer.data(), buffer.length());
+}
+
 void MediaBrowserTest::AddTitlesToAwait(content::TitleWatcher* title_watcher) {
   title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kEnded));
   title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kError));
   title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kErrorEvent));
   title_watcher->AlsoWaitForTitle(base::ASCIIToUTF16(kFailed));
 }
 
 // Tests playback and seeking of an audio or video file over file or http based
 // on a test parameter.  Test starts with playback, then, after X seconds or the
 // ended event fires, seeks near end of file; see player.html for details.  The
@@ skipping 12 matching lines @@
   }
 
   void PlayMedia(const std::string& tag,
                  const std::string& media_file,
                  bool http) {
     base::StringPairs query_params;
     query_params.push_back(std::make_pair(tag, media_file));
     RunMediaTestPage("player.html", query_params, kEnded, http);
   }
 
+  void TestErrorMessage(const std::string& tag,

[sandersd (OOO until July 31), 2017/04/12 01:09:37]

Rename as RunErrorMessageTest to match other variants?

[wolenetz, 2017/04/13 23:59:10]

Done.

+                        const std::string& media_file,
+                        const std::string& expected_error_substring,
+                        bool http) {
+    base::StringPairs query_params;
+    query_params.push_back(std::make_pair(tag, media_file));
+    query_params.push_back(
+        std::make_pair("error_substr", expected_error_substring));
+    RunMediaTestPage("player.html", query_params, kErrorEvent, http);
+  }
+
   void RunVideoSizeTest(const char* media_file, int width, int height) {
     std::string expected;
     expected += base::IntToString(width);
     expected += " ";
     expected += base::IntToString(height);
     base::StringPairs query_params;
     query_params.push_back(std::make_pair("video", media_file));
     RunMediaTestPage("player.html", query_params, expected, false);
   }
 };
@@ skipping 137 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_P(MediaTest, VideoBearWavPcm192kHz) {
   PlayAudio("bear_192kHz.wav", GetParam());
 }
 
 IN_PROC_BROWSER_TEST_P(MediaTest, VideoTulipWebm) {
   PlayVideo("tulip2.webm", GetParam());
 }
 
+IN_PROC_BROWSER_TEST_P(MediaTest, VideoErrorMissingResource) {
+  TestErrorMessage("video", "nonexistent_file.webm",
+                   "{\"MediaElementError\":[\"Format error\"]}", GetParam());
+}
+
+IN_PROC_BROWSER_TEST_P(MediaTest, VideoErrorEmptySrcAttribute) {
+  TestErrorMessage("video", "",
+                   "{\"MediaElementError\":[\"Empty src attribute\"]}",
+                   GetParam());
+}
+
+IN_PROC_BROWSER_TEST_P(MediaTest, VideoNoSupportedStreams) {
+  TestErrorMessage("video", "no_streams.webm",
+                   "{\"MEDIA_ERROR_LOG_ENTRY\":[\"{\\\"error\\\":"
+                   "\\\"FFmpegDemuxer: no supported "
+                   "streams\\\"}\"],\"PIPELINE_ERROR\":[\"demuxer: no "
+                   "supported streams\"]}",

[sandersd (OOO until July 31), 2017/04/12 01:09:37]

This format seems overly complex and exposes rather more internal detail than I
was hoping. The object structure here is:

{
  "MEDIA_ERROR_LOG_ENTRY": [ "{\"error\":\"FFmpegDemuxer: no supported
streams\"}" ],
  "PIPELINE_ERROR": [ "demuxer: no supported streams" ]
}

I would propose:

{
  "cause": "demuxer: no supported streams",
  "error_log": [ "FFmpegDemuxer: no supported streams" ]
}

[wolenetz, 2017/04/13 23:59:10]

Done. See related discussion thread
https://codereview.chromium.org/2660003003/#msg28

+                   GetParam());
+}
+
 // Covers tear-down when navigating away as opposed to browser exiting.
 IN_PROC_BROWSER_TEST_F(MediaTest, Navigate) {
   PlayVideo("bear.webm", false);
   NavigateToURL(shell(), GURL(url::kAboutBlankURL));
   EXPECT_FALSE(shell()->web_contents()->IsCrashed());
 }
 
 INSTANTIATE_TEST_CASE_P(File, MediaTest, ::testing::Values(false));
 INSTANTIATE_TEST_CASE_P(Http, MediaTest, ::testing::Values(true));
 
 }  // namespace content