[experimental] MR: add support for H264 recording

content/renderer/media/video_track_recorder_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 "content/renderer/media/video_track_recorder.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 22 matching lines @@
 using ::testing::SaveArg;
 using ::testing::TestWithParam;
 using ::testing::ValuesIn;
 
 namespace content {
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
-const bool kTrackRecorderTestUseVp9OrNot[] = {false, true};
+const VideoTrackRecorder::CodecId kTrackRecorderTestCodec[] = {
+    VideoTrackRecorder::CodecId::VP8, VideoTrackRecorder::CodecId::VP9,
+    VideoTrackRecorder::CodecId::H264};
 
-class VideoTrackRecorderTest : public TestWithParam<bool> {
+class VideoTrackRecorderTest
+    : public TestWithParam<VideoTrackRecorder::CodecId> {
  public:
   VideoTrackRecorderTest()
       : mock_source_(new MockMediaStreamVideoSource(false)) {
     const blink::WebString webkit_track_id(base::UTF8ToUTF16("dummy"));
     blink_source_.initialize(webkit_track_id,
                              blink::WebMediaStreamSource::TypeVideo,
                              webkit_track_id);
     blink_source_.setExtraData(mock_source_);
     blink_track_.initialize(blink_source_);
 
     blink::WebMediaConstraints constraints;
     constraints.initialize();
     track_ = new MediaStreamVideoTrack(mock_source_, constraints,
                                        MediaStreamSource::ConstraintsCallback(),
                                        true /* enabled */);
     blink_track_.setExtraData(track_);
 
     video_track_recorder_.reset(new VideoTrackRecorder(
-        GetParam() /* use_vp9 */, blink_track_,
+        GetParam() /* codec */, blink_track_,
         base::Bind(&VideoTrackRecorderTest::OnEncodedVideo,
                    base::Unretained(this)),
         0 /* bits_per_second */));
     // Paranoia checks.
     EXPECT_EQ(blink_track_.source().getExtraData(),
               blink_source_.getExtraData());
     EXPECT_TRUE(message_loop_.IsCurrent());
   }
 
   ~VideoTrackRecorderTest() {
@@ skipping 81 matching lines @@
 
   base::StringPiece third_frame_encoded_data;
   EXPECT_CALL(*this, DoOnEncodedVideo(video_frame2, _, _, true))
       .Times(1)
       .WillOnce(DoAll(SaveArg<1>(&third_frame_encoded_data),
                 RunClosure(quit_closure)));
   Encode(video_frame2, base::TimeTicks::Now());
 
   run_loop.Run();
 
-  const size_t kEncodedSizeThreshold = 18;
+  const size_t kEncodedSizeThreshold = 14;
   EXPECT_GE(first_frame_encoded_data.size(), kEncodedSizeThreshold);
   EXPECT_GE(second_frame_encoded_data.size(), kEncodedSizeThreshold);
   EXPECT_GE(third_frame_encoded_data.size(), kEncodedSizeThreshold);
 
   Mock::VerifyAndClearExpectations(this);
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         VideoTrackRecorderTest,
-                        ValuesIn(kTrackRecorderTestUseVp9OrNot));
+                        ValuesIn(kTrackRecorderTestCodec));
 
 }  // namespace content