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

content/renderer/media/webrtc_audio_device_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
@@ skipping 117 matching lines @@
   webrtc_audio_device->AddAudioCapturer(capturer);
 
   return true;
 }
 
 // Create and start a local audio track. Starting the audio track will connect
 // the audio track to the capturer and also start the source of the capturer.
 // Also, connect the sink to the audio track.
 scoped_refptr<WebRtcLocalAudioTrack>
 CreateAndStartLocalAudioTrack(WebRtcAudioCapturer* capturer,
-                              WebRtcAudioCapturerSink* sink) {
+                              PeerConnectionAudioSink* sink) {
   scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
       WebRtcLocalAudioTrack::Create(std::string(), capturer, NULL, NULL, NULL));
   local_audio_track->AddSink(sink);
   local_audio_track->Start();
   return local_audio_track;
 }
 
 class WebRTCMediaProcessImpl : public webrtc::VoEMediaProcess {
  public:
   explicit WebRTCMediaProcessImpl(base::WaitableEvent* event)
@@ skipping 49 matching lines @@
   base::WaitableEvent* event_;
   int channel_id_;
   webrtc::ProcessingTypes type_;
   int packet_size_;
   int sample_rate_;
   int channels_;
   mutable base::Lock lock_;
   DISALLOW_COPY_AND_ASSIGN(WebRTCMediaProcessImpl);
 };
 
-class MockWebRtcAudioCapturerSink : public WebRtcAudioCapturerSink {
+// TODO(xians): Use MediaStreamAudioSink.
+class MockMediaStreamAudioSink : public PeerConnectionAudioSink {
  public:
-  explicit MockWebRtcAudioCapturerSink(base::WaitableEvent* event)
+  explicit MockMediaStreamAudioSink(base::WaitableEvent* event)
       : event_(event) {
     DCHECK(event_);
   }
-  virtual ~MockWebRtcAudioCapturerSink() {}
+  virtual ~MockMediaStreamAudioSink() {}
 
-  // WebRtcAudioCapturerSink implementation.
-  virtual int CaptureData(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) OVERRIDE {
+  // PeerConnectionAudioSink implementation.
+  virtual int OnData(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) OVERRIDE {
     // Signal that a callback has been received.
     event_->Signal();
     return 0;
   }
 
   // Set the format for the capture audio parameters.
-  virtual void SetCaptureFormat(
+  virtual void OnSetFormat(
       const media::AudioParameters& params) OVERRIDE {}
 
  private:
    base::WaitableEvent* event_;
 
-   DISALLOW_COPY_AND_ASSIGN(MockWebRtcAudioCapturerSink);
+   DISALLOW_COPY_AND_ASSIGN(MockMediaStreamAudioSink);
 };
 
 class MockWebRtcAudioRendererSource : public WebRtcAudioRendererSource {
  public:
   explicit MockWebRtcAudioRendererSource(base::WaitableEvent* event)
       : event_(event) {
     DCHECK(event_);
   }
   virtual ~MockWebRtcAudioRendererSource() {}
 
@@ skipping 73 matching lines @@
                               bool enable_apm) {
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   EXPECT_TRUE(engine.valid());
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   EXPECT_TRUE(base.valid());
   int err = base->Init(webrtc_audio_device.get());
   EXPECT_EQ(0, err);
 
-  // We use SetCaptureFormat() and SetRenderFormat() to configure the audio
+  // We use OnSetFormat() and SetRenderFormat() to configure the audio
   // parameters so that this test can run on machine without hardware device.
   const media::AudioParameters params = media::AudioParameters(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
       48000, 2, 480);
-  WebRtcAudioCapturerSink* capturer_sink =
-      static_cast<WebRtcAudioCapturerSink*>(webrtc_audio_device.get());
+  PeerConnectionAudioSink* capturer_sink =
+      static_cast<PeerConnectionAudioSink*>(webrtc_audio_device.get());
   WebRtcAudioRendererSource* renderer_source =
       static_cast<WebRtcAudioRendererSource*>(webrtc_audio_device.get());
   renderer_source->SetRenderFormat(params);
 
   // Turn on/off all the signal processing components like AGC, AEC and NS.
   ScopedWebRTCPtr<webrtc::VoEAudioProcessing> audio_processing(engine.get());
   EXPECT_TRUE(audio_processing.valid());
   audio_processing->SetAgcStatus(enable_apm);
   audio_processing->SetNsStatus(enable_apm);
   audio_processing->SetEcStatus(enable_apm);
@@ skipping 23 matching lines @@
   ReadDataFromSpeechFile(capture_data.get(), length);
 
   // Start the timer.
   scoped_ptr<uint8[]> buffer(new uint8[output_packet_size]);
   base::Time start_time = base::Time::Now();
   int delay = 0;
   std::vector<int> voe_channels;
   voe_channels.push_back(channel);
   for (int j = 0; j < kNumberOfPacketsForLoopbackTest; ++j) {
     // Sending fake capture data to WebRtc.
-    capturer_sink->CaptureData(
-        voe_channels,
+    capturer_sink->OnData(
         reinterpret_cast<int16*>(capture_data.get() + input_packet_size * j),
         params.sample_rate(),
         params.channels(),
         params.frames_per_buffer(),
+        voe_channels,
         kHardwareLatencyInMs,
         1.0,
         enable_apm,
         false);
 
     // Receiving data from WebRtc.
     renderer_source->RenderData(
         reinterpret_cast<uint8*>(buffer.get()),
         num_output_channels, webrtc_audio_device->output_buffer_size(),
         kHardwareLatencyInMs + delay);
@@ skipping 455 matching lines @@
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
   int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
   EXPECT_TRUE(CreateAndInitializeCapturer(webrtc_audio_device.get()));
   base::WaitableEvent event(false, false);
-  scoped_ptr<MockWebRtcAudioCapturerSink> sink(
-      new MockWebRtcAudioCapturerSink(&event));
+  scoped_ptr<MockMediaStreamAudioSink> sink(
+      new MockMediaStreamAudioSink(&event));
 
   // Create and start a local audio track. Starting the audio track will connect
   // the audio track to the capturer and also start the source of the capturer.
   scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
       CreateAndStartLocalAudioTrack(
           webrtc_audio_device->GetDefaultCapturer().get(), sink.get()));
 
   // connect the VoE voice channel to the audio track.
   static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
       GetRenderer()->AddChannel(ch);
@@ skipping 93 matching lines @@
     LOG(WARNING) << "Test disabled due to the test hangs on WinXP.";
     return;
   }
 #endif
   int latency = RunWebRtcLoopbackTimeTest(audio_manager_.get(), true);
   PrintPerfResultMs("webrtc_loopback_with_signal_processing (100 packets)",
                     "t", latency);
 }
 
 }  // namespace content