MediaRecorder: support |timecode| and remove |m_ignoreMutedMedia|.

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 <string>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 67 matching lines @@
     EXPECT_FALSE(media_recorder_handler_->recording_);
 
     registry_.Init(kTestStreamUrl);
   }
 
   ~MediaRecorderHandlerTest() {
     registry_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
-  MOCK_METHOD3(writeData, void(const char*, size_t, bool));
+  MOCK_METHOD4(writeData, void(const char*, size_t, bool, double));
   MOCK_METHOD1(onError, void(const WebString& message));
 
   bool recording() const { return media_recorder_handler_->recording_; }
   bool hasVideoRecorders() const {
     return !media_recorder_handler_->video_recorders_.empty();
   }
   bool hasAudioRecorders() const {
     return !media_recorder_handler_->audio_recorders_.empty();
   }
 
@@ skipping 103 matching lines @@
 
   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);
+  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, codecs, 0, 0));
   EXPECT_TRUE(media_recorder_handler_->start(0));
 
   InSequence s;
   const scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::CreateBlackFrame(gfx::Size(160, 80));
 
   {
     const size_t kEncodedSizeThreshold = 16;
     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), _))
+    EXPECT_CALL(*this, writeData(_, Lt(kEncodedSizeThreshold), _, _))
         .Times(AtLeast(1));
-    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _))
+    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _, _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
     OnVideoFrameForTesting(video_frame);
     run_loop.Run();
   }
   Mock::VerifyAndClearExpectations(this);
 
   {
     const size_t kEncodedSizeThreshold = 13;
     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), _))
+    EXPECT_CALL(*this, writeData(_, Lt(kEncodedSizeThreshold), _, _))
         .Times(AtLeast(1));
-    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _))
+    EXPECT_CALL(*this, writeData(_, Gt(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.
-  EXPECT_CALL(*this, writeData(nullptr, 0, true)).Times(1);
+  EXPECT_CALL(*this, writeData(nullptr, 0, true, _)).Times(1);
   media_recorder_handler_.reset();
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         MediaRecorderHandlerTest,
                         ValuesIn(kMediaRecorderTestParams));
 
 // Sends 2 frames and expect them as WebM contained encoded data in writeData().
 TEST_P(MediaRecorderHandlerTest, EncodeAudioFrames) {
   // Audio-only test.
@@ skipping 16 matching lines @@
       kTestAudioSampleRate, kTestAudioBitsPerSample,
       kTestAudioSampleRate * kTestAudioBufferDurationMs / 1000);
   SetAudioFormatForTesting(params);
 
   const size_t kEncodedSizeThreshold = 24;
   {
     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), _))
+    EXPECT_CALL(*this, writeData(_, Lt(kEncodedSizeThreshold), _, _))
         .Times(AtLeast(1));
-    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _))
+    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _, _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
     for (int i = 0; i < kRatioOpusToTestAudioBuffers; ++i)
       OnAudioBusForTesting(*audio_bus1);
     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), _))
+    EXPECT_CALL(*this, writeData(_, Lt(kEncodedSizeThreshold), _, _))
         .Times(AtLeast(1));
-    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _))
+    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _, _))
         .Times(1)
         .WillOnce(RunClosure(quit_closure));
 
     for (int i = 0; i < kRatioOpusToTestAudioBuffers; ++i)
       OnAudioBusForTesting(*audio_bus2);
     run_loop.Run();
   }
 
   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);
+  EXPECT_CALL(*this, writeData(nullptr, 0, true, _)).Times(1);
   media_recorder_handler_.reset();
 }
 
 }  // namespace content