MediaRecorder: support sampling rate adaption in AudioTrackRecorder

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"
@@ skipping 23 matching lines @@
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 static const std::string kTestStreamUrl = "stream_url";
 static const std::string kTestVideoTrackId = "video_track_id";
 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;
+// MediaStream Audio Tack always provides chunks 10 ms of audio data.
+static const int kMediaStreamAudioTrackBufferDurationMs = 10;
 
 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/webm", "vp8", 52, 32, 0, 0},
     {true, false, "video/webm", "vp9", 33, 18, 0, 0},
-    {false, true, "video/webm", "vp8", 0, 0, 990, 706}};
+    {false, true, "video/webm", "vp8", 0, 0, 248, 125}};
 
 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 33 matching lines @@
     // Avoid issues with non-parameterized tests by calling this outside of ctr.
     if (GetParam().has_video)
       registry_.AddVideoTrack(kTestVideoTrackId);
     if (GetParam().has_audio)
       registry_.AddAudioTrack(kTestAudioTrackId);
   }
 
   scoped_ptr<media::AudioBus> NextAudioBus() {
     scoped_ptr<media::AudioBus> bus(media::AudioBus::Create(
         kTestAudioChannels,
-        kTestAudioSampleRate * kTestAudioBufferDurationMS / 1000));
+        kTestAudioSampleRate * kMediaStreamAudioTrackBufferDurationMs / 1000));
     audio_source_.OnMoreData(bus.get(), 0, 0);
     return bus;
   }
 
   // A ChildProcess and a MessageLoopForUI are both needed to fool the Tracks
   // and Sources in |registry_| into believing they are on the right threads.
   const base::MessageLoopForUI message_loop_;
   const ChildProcess child_process_;
   MockMediaStreamRegistry registry_;
 
@@ skipping 152 matching lines @@
                                                   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);
+      kTestAudioSampleRate * kMediaStreamAudioTrackBufferDurationMs / 1000);
   SetAudioFormatForTesting(params);
 
   {
     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.
     const size_t kEncodedDataSize = GetParam().first_encoded_audio_frame_size;
     EXPECT_CALL(*this, writeData(_, Lt(kEncodedDataSize), _)).Times(AtLeast(1));
     EXPECT_CALL(*this, writeData(_, kEncodedDataSize, _))
@@ skipping 22 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