Add generic interfaces for the sinks of the media stream audio track

content/renderer/media/webrtc_audio_capturer_unittest.cc

 // Copyright 2013 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/logging.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_local_audio_track.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
@@ skipping 47 matching lines @@
                                 int session_id));
   MOCK_METHOD0(Start, void());
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(SetVolume, void(double volume));
   MOCK_METHOD1(SetAutomaticGainControl, void(bool enable));
 
  protected:
   virtual ~MockCapturerSource() {}
 };
 
-class MockWebRtcAudioCapturerSink : public WebRtcAudioCapturerSink {
+class MockPeerConnectionAudioSink : public PeerConnectionAudioSink {
  public:
-  MockWebRtcAudioCapturerSink() {}
-  ~MockWebRtcAudioCapturerSink() {}
-  MOCK_METHOD9(CaptureData, int(const std::vector<int>& channels,
-                                const int16* audio_data,
-                                int sample_rate,
-                                int number_of_channels,
-                                int number_of_frames,
-                                int audio_delay_milliseconds,
-                                int current_volume,
-                                bool need_audio_processing,
-                                bool key_pressed));
-  MOCK_METHOD1(SetCaptureFormat, void(const media::AudioParameters& params));
+  MockPeerConnectionAudioSink() {}
+  ~MockPeerConnectionAudioSink() {}
+  MOCK_METHOD9(OnData, int(const int16* audio_data,
+                           int sample_rate,
+                           int number_of_channels,
+                           int number_of_frames,
+                           const std::vector<int>& channels,
+                           int audio_delay_milliseconds,
+                           int current_volume,
+                           bool need_audio_processing,
+                           bool key_pressed));
+  MOCK_METHOD1(OnSetFormat, void(const media::AudioParameters& params));
 };
 
 }  // namespace
 
 class WebRtcAudioCapturerTest : public testing::Test {
  protected:
   WebRtcAudioCapturerTest()
 #if defined(OS_ANDROID)
       : params_(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                 media::CHANNEL_LAYOUT_STEREO, 48000, 16, 960) {
@@ skipping 26 matching lines @@
   media::AudioParameters params_;
   scoped_refptr<MockCapturerSource> capturer_source_;
   scoped_refptr<WebRtcAudioCapturer> capturer_;
   scoped_refptr<WebRtcLocalAudioTrack> track_;
 };
 
 // Pass the delay value, vollume and key_pressed info via capture callback, and
 // those values should be correctly stored and passed to the track.
 TEST_F(WebRtcAudioCapturerTest, VerifyAudioParams) {
   // Connect a mock sink to the track.
-  scoped_ptr<MockWebRtcAudioCapturerSink> sink(
-      new MockWebRtcAudioCapturerSink());
+  scoped_ptr<MockPeerConnectionAudioSink> sink(
+      new MockPeerConnectionAudioSink());
   track_->AddSink(sink.get());
 
   int delay_ms = 65;
   bool key_pressed = true;
   double volume = 0.9;
   // MaxVolume() in WebRtcAudioCapturer is hard-coded to return 255, we add 0.5
   // to do the correct truncation as how the production code does.
   int expected_volume_value = volume * capturer_->MaxVolume() + 0.5;
   scoped_ptr<media::AudioBus> audio_bus = media::AudioBus::Create(params_);
   audio_bus->Zero();
 #if defined(OS_ANDROID)
   const int expected_buffer_size = params_.sample_rate() / 100;
 #else
   const int expected_buffer_size = params_.frames_per_buffer();
 #endif
   bool expected_need_audio_processing = true;
   media::AudioCapturerSource::CaptureCallback* callback =
       static_cast<media::AudioCapturerSource::CaptureCallback*>(capturer_);
   // Verify the sink is getting the correct values.
-  EXPECT_CALL(*sink, SetCaptureFormat(_));
+  EXPECT_CALL(*sink, OnSetFormat(_));
   EXPECT_CALL(*sink,
-              CaptureData(_, _, params_.sample_rate(), params_.channels(),
-                          expected_buffer_size, delay_ms,
-                          expected_volume_value, expected_need_audio_processing,
-                          key_pressed)).Times(AtLeast(1));
+              OnData(_, params_.sample_rate(), params_.channels(),
+                     expected_buffer_size, _, delay_ms,
+                     expected_volume_value, expected_need_audio_processing,
+                     key_pressed)).Times(AtLeast(1));
   callback->Capture(audio_bus.get(), delay_ms, volume, key_pressed);
 
   // Verify the cached values in the capturer fits what we expect.
   base::TimeDelta cached_delay;
   int cached_volume = !expected_volume_value;
   bool cached_key_pressed = !key_pressed;
   capturer_->GetAudioProcessingParams(&cached_delay, &cached_volume,
                                       &cached_key_pressed);
   EXPECT_EQ(cached_delay.InMilliseconds(), delay_ms);
   EXPECT_EQ(cached_volume, expected_volume_value);
   EXPECT_EQ(cached_key_pressed, key_pressed);
 
   track_->RemoveSink(sink.get());
   EXPECT_CALL(*capturer_source_.get(), Stop());
   capturer_->Stop();
 }
 
 }  // namespace content