[experimental] MR: add support for H264 recording

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 <stddef.h>
 
 #include "base/macros.h"
 #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"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::InSequence;
+using ::testing::Ge;
 using ::testing::Gt;
 using ::testing::Lt;
 using ::testing::Mock;
 using ::testing::TestWithParam;
 using ::testing::ValuesIn;
 
 using blink::WebString;
 
 namespace content {
 
@@ skipping 17 matching lines @@
   const bool has_audio;
   const char* const mime_type;
   const char* const codecs;
 };
 
 // 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/webm", "vp8"},
     {true, false, "video/webm", "vp9"},
+    {true, false, "video/webm", "h264"},
     {false, true, "video/webm", "vp8"}};
 
 class MediaRecorderHandlerTest : public TestWithParam<MediaRecorderTestParams>,
                                  public blink::WebMediaRecorderHandlerClient {
  public:
   MediaRecorderHandlerTest()
       : media_recorder_handler_(new MediaRecorderHandler()),
         audio_source_(kTestAudioChannels,
                       440 /* freq */,
                       kTestAudioSampleRate) {
@@ skipping 77 matching lines @@
                   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 example_good_codecs_4(base::UTF8ToUTF16("H264,opus"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_video, example_good_codecs_4));
 
   const WebString example_unsupported_codecs_1(base::UTF8ToUTF16("daala"));
   EXPECT_FALSE(media_recorder_handler_->canSupportMimeType(
                    mime_type_video, example_unsupported_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_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"));
+  const WebString example_good_codecs_5(base::UTF8ToUTF16("opus"));
   EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
                   mime_type_audio, example_good_codecs_5));
+  const WebString example_good_codecs_6(base::UTF8ToUTF16("OpUs"));
+  EXPECT_TRUE(media_recorder_handler_->canSupportMimeType(
+                  mime_type_audio, example_good_codecs_6));
 
   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));
@@ skipping 31 matching lines @@
   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, codecs, 0, 0));
   EXPECT_TRUE(media_recorder_handler_->start());
 
   InSequence s;
   const scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::CreateBlackFrame(gfx::Size(160, 80));
 
-  const size_t kEncodedSizeThreshold = 16;
+  const size_t kEncodedSizeThreshold = 14;
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     // writeData() is pinged a number of times as the WebM header is written;
     // the last time it is called it has the encoded data.
     EXPECT_CALL(*this, writeData(_, Lt(kEncodedSizeThreshold), _))
         .Times(AtLeast(1));
-    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _))
+    EXPECT_CALL(*this, writeData(_, Ge(kEncodedSizeThreshold), _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
     OnVideoFrameForTesting(video_frame);
     run_loop.Run();
   }
   Mock::VerifyAndClearExpectations(this);
 
   {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     // The second time around writeData() is called a number of times to write
     // the WebM frame header, and then is pinged with the encoded data.
     EXPECT_CALL(*this, writeData(_, Lt(kEncodedSizeThreshold), _))
         .Times(AtLeast(1));
-    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _))
+    EXPECT_CALL(*this, writeData(_, Ge(kEncodedSizeThreshold), _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
     OnVideoFrameForTesting(video_frame);
     run_loop.Run();
   }
 
   media_recorder_handler_->stop();
 
   // Expect a last call on destruction, with size 0 and |lastInSlice| true.
@@ skipping 63 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