MediaRecorder: correct MIME type parsing

content/renderer/media/media_recorder_handler_unittest.cc

Index: content/renderer/media/media_recorder_handler_unittest.cc
diff --git a/content/renderer/media/media_recorder_handler_unittest.cc b/content/renderer/media/media_recorder_handler_unittest.cc
index 57fb60d02da9fef49b7c6d02053c52da3d8d2b72..1eaef015415b7b258820b01d7c55d1caf72e6902 100644
--- a/content/renderer/media/media_recorder_handler_unittest.cc
+++ b/content/renderer/media/media_recorder_handler_unittest.cc
@@ -44,6 +44,7 @@ struct MediaRecorderTestParams {
   const bool has_video;
   const bool has_audio;
   const char* const mime_type;
+  const char* const codecs;
   const size_t first_encoded_video_frame_size;
   const size_t second_encoded_video_frame_size;
   const size_t first_encoded_audio_frame_size;
@@ -51,9 +52,9 @@ struct MediaRecorderTestParams {
 };
 
 static const MediaRecorderTestParams kMediaRecorderTestParams[] = {

[tommi (sloooow) - chröme, 2015/12/18 10:06:30]

Can you document what this array contains? Does it contain supported values
only, video types only, meant for testing valid cases, invalid?

[mcasas, 2015/12/18 21:27:45]

Done.

-    {true, false, "video/vp8", 52, 32, 0, 0},
-    {true, false, "video/vp9", 33, 18, 0, 0},
-    {false, true, "video/vp8", 0, 0, 990, 706}};
+    {true, false, "video/webm", "vp8", 52, 32, 0, 0},
+    {true, false, "video/webm", "vp9", 33, 18, 0, 0},
+    {false, true, "video/webm", "vp8", 0, 0, 990, 706}};
 
 class MediaRecorderHandlerTest : public TestWithParam<MediaRecorderTestParams>,
                                  public blink::WebMediaRecorderHandlerClient {
@@ -131,37 +132,44 @@ class MediaRecorderHandlerTest : public TestWithParam<MediaRecorderTestParams>,
 };
 
 // Checks that canSupportMimeType() works as expected.
-// TODO(mcasas): revisit this when canSupportMimeType() is fully implemented.
 TEST_F(MediaRecorderHandlerTest, CanSupportMimeType) {
-  const WebString good_mime_type_vp8(base::UTF8ToUTF16("video/vp8"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(good_mime_type_vp8));
-
-  const WebString good_mime_type_vp9(base::UTF8ToUTF16("video/vp9"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(good_mime_type_vp9));
-
-  const WebString audio_mime_type(base::UTF8ToUTF16("audio/opus"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(audio_mime_type));
-
-  const WebString combo_mime_type(base::UTF8ToUTF16("video/vp8, audio/opus"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(combo_mime_type));
-
-  const WebString bad_combo(base::UTF8ToUTF16("video/vp8, audio/unsupported"));
-  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(bad_combo));
-
-  const WebString bad_mime_type(base::UTF8ToUTF16("video/unsupportedcodec"));
-  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(bad_mime_type));
-
-  const WebString empty_mime_type(base::UTF8ToUTF16(""));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(empty_mime_type));
+  const WebString bad_mime_type(base::UTF8ToUTF16("video/mpeg"));
+  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
+                   bad_mime_type, WebString()));
+
+  const WebString mime_type_video(base::UTF8ToUTF16("video/webm"));

[tommi (sloooow) - chröme, 2015/12/18 10:06:30]

suggest tests for mixed case mime types as well as testing for not-supported
input.

[mcasas, 2015/12/18 21:27:45]

Done.
(Note that there were a few negative cases 
EXPECT_FALSE already)

+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video, WebString()));
+  const WebString example_good_codecs_1(base::UTF8ToUTF16("vp8"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video, example_good_codecs_1));
+  const WebString example_good_codecs_2(base::UTF8ToUTF16("vp9,opus"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video, example_good_codecs_2));
+  const WebString example_bad_codecs_1(base::UTF8ToUTF16("daala"));
+  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
+                   mime_type_video, example_bad_codecs_1));
+
+  const WebString mime_type_audio(base::UTF8ToUTF16("audio/webm"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_audio, WebString()));
+  const WebString example_good_codecs_3(base::UTF8ToUTF16("opus"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_audio, example_good_codecs_3));
+  const WebString example_bad_codecs_2(base::UTF8ToUTF16("vorbis"));
+  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
+                   mime_type_audio, example_bad_codecs_2));
 }
 
 // Checks that the initialization-destruction sequence works fine.
 TEST_P(MediaRecorderHandlerTest, InitializeStartStop) {
   AddTracks();
   const WebString mime_type(base::UTF8ToUTF16(GetParam().mime_type));
+  const WebString codecs(base::UTF8ToUTF16(GetParam().codecs));
   EXPECT_TRUE(media_recorder_handler_->initialize(this,
                                                   registry_.test_stream(),
-                                                  mime_type));
+                                                  mime_type,
+                                                  codecs));
   EXPECT_FALSE(recording());
   EXPECT_FALSE(hasVideoRecorders());
   EXPECT_FALSE(hasAudioRecorders());
@@ -191,8 +199,9 @@ TEST_P(MediaRecorderHandlerTest, EncodeVideoFrames) {
   AddTracks();
 
   const WebString mime_type(base::UTF8ToUTF16(GetParam().mime_type));
+  const WebString codecs(base::UTF8ToUTF16(GetParam().codecs));
   EXPECT_TRUE(media_recorder_handler_->initialize(this, registry_.test_stream(),
-                                                  mime_type));
+                                                  mime_type, codecs));
   EXPECT_TRUE(media_recorder_handler_->start());
 
   InSequence s;
@@ -250,9 +259,9 @@ TEST_P(MediaRecorderHandlerTest, EncodeAudioFrames) {
 
   AddTracks();
 
-  const WebString mime_type(base::UTF8ToUTF16("audio/opus"));
+  const WebString mime_type(base::UTF8ToUTF16("audio/webm"));
   EXPECT_TRUE(media_recorder_handler_->initialize(this, registry_.test_stream(),
-                                                  mime_type));
+                                                  mime_type, WebString()));
   EXPECT_TRUE(media_recorder_handler_->start());
 
   InSequence s;