MediaRecorder: correct MIME type parsing

content/renderer/media/media_recorder_handler_unittest.cc

 // 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 "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_recorder_handler.h"
 #include "content/renderer/media/mock_media_stream_registry.h"
 #include "media/audio/simple_sources.h"
@@ skipping 26 matching lines @@
 static const std::string kTestAudioTrackId = "audio_track_id";
 static const int kTestAudioChannels = 2;
 static const int kTestAudioBitsPerSample = 16;
 static const int kTestAudioSampleRate = 48000;
 static const int kTestAudioBufferDurationMS = 60;
 
 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;
   const size_t second_encoded_audio_frame_size;
 };
 
+// Array of valid combinations of video/audio/codecs and expected collected
+// encoded sizes to use for parameterizing MediaRecorderHandlerTest.
 static const MediaRecorderTestParams kMediaRecorderTestParams[] = {
-    {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 {
  public:
   MediaRecorderHandlerTest()
       : media_recorder_handler_(new MediaRecorderHandler()),
         audio_source_(kTestAudioChannels,
                       440 /* freq */,
                       kTestAudioSampleRate) {
     EXPECT_FALSE(media_recorder_handler_->recording_);
@@ skipping 56 matching lines @@
   // The Class under test. Needs to be scoped_ptr to force its destruction.
   scoped_ptr<MediaRecorderHandler> media_recorder_handler_;
 
   // For generating test AudioBuses
   media::SineWaveAudioSource audio_source_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MediaRecorderHandlerTest);
 };
 
-// Checks that canSupportMimeType() works as expected.
-// TODO(mcasas): revisit this when canSupportMimeType() is fully implemented.
+// Checks that canSupportMimeType() works as expected, by sending supported
+// combinations and unsupported ones.
 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 unsupported_mime_type(base::UTF8ToUTF16("video/mpeg"));
+  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
+                   unsupported_mime_type, WebString()));
 
-  const WebString good_mime_type_vp9(base::UTF8ToUTF16("video/vp9"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(good_mime_type_vp9));
+  const WebString mime_type_video(base::UTF8ToUTF16("video/webm"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video, WebString()));
+  const WebString mime_type_video_uppercase(base::UTF8ToUTF16("video/WEBM"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video_uppercase, 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_good_codecs_3(base::UTF8ToUTF16("VP9,opus"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video, example_good_codecs_3));
 
-  const WebString audio_mime_type(base::UTF8ToUTF16("audio/opus"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(audio_mime_type));
+  const WebString example_unsupported_codecs_1(base::UTF8ToUTF16("daala"));
+  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
+                   mime_type_video, example_unsupported_codecs_1));
 
-  const WebString combo_mime_type(base::UTF8ToUTF16("video/vp8, audio/opus"));
-  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(combo_mime_type));
+  const WebString mime_type_audio(base::UTF8ToUTF16("audio/webm"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_audio, WebString()));
+  const WebString example_good_codecs_4(base::UTF8ToUTF16("opus"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_audio, example_good_codecs_4));
+  const WebString example_good_codecs_5(base::UTF8ToUTF16("OpUs"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_audio, example_good_codecs_5));
 
-  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 example_unsupported_codecs_2(base::UTF8ToUTF16("vorbis"));
+  EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
+                   mime_type_audio, example_unsupported_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());
 
   EXPECT_TRUE(media_recorder_handler_->start());
   EXPECT_TRUE(recording());
 
   EXPECT_TRUE(hasVideoRecorders() || !GetParam().has_video);
   EXPECT_TRUE(hasAudioRecorders() || !GetParam().has_audio);
 
   media_recorder_handler_->stop();
   EXPECT_FALSE(recording());
   EXPECT_FALSE(hasVideoRecorders());
   EXPECT_FALSE(hasAudioRecorders());
 
   // Expect a last call on destruction.
   EXPECT_CALL(*this, writeData(_, _, true)).Times(1);
   media_recorder_handler_.reset();
 }
 
 // Sends 2 frames and expect them as WebM contained encoded data in writeData().
 TEST_P(MediaRecorderHandlerTest, EncodeVideoFrames) {
   // Video-only test.
   if (GetParam().has_audio)
     return;
 
   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;
   const scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::CreateBlackFrame(gfx::Size(160, 80));
 
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     // writeData() is pinged a number of times as the WebM header is written;
@@ skipping 37 matching lines @@
                         ValuesIn(kMediaRecorderTestParams));
 
 // Sends 2 frames and expect them as WebM contained encoded data in writeData().
 TEST_P(MediaRecorderHandlerTest, EncodeAudioFrames) {
   // Audio-only test.
   if (GetParam().has_video)
     return;
 
   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;
   const scoped_ptr<media::AudioBus> audio_bus1 = NextAudioBus();
   const scoped_ptr<media::AudioBus> audio_bus2 = NextAudioBus();
 
   media::AudioParameters params(
       media::AudioParameters::AUDIO_PCM_LINEAR, media::CHANNEL_LAYOUT_STEREO,
       kTestAudioSampleRate, kTestAudioBitsPerSample,
       kTestAudioSampleRate * kTestAudioBufferDurationMS / 1000);
@@ skipping 32 matching lines @@
   }
 
   media_recorder_handler_->stop();
 
   // Expect a last call on destruction, with size 0 and |lastInSlice| true.
   EXPECT_CALL(*this, writeData(nullptr, 0, true)).Times(1);
   media_recorder_handler_.reset();
 }
 
 }  // namespace content