Upstream version 5.34.104.0

[platform/framework/web/crosswalk.git] / src / content / renderer / media / webrtc_audio_device_unittest.cc

diff --git a/src/content/renderer/media/webrtc_audio_device_unittest.cc b/src/content/renderer/media/webrtc_audio_device_unittest.cc
index 5545ec7..faf7aa1 100644 (file)
--- a/src/content/renderer/media/webrtc_audio_device_unittest.cc
+++ b/src/content/renderer/media/webrtc_audio_device_unittest.cc
@@ -10,6 +10,8 @@
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_timeouts.h"
+#include "content/renderer/media/mock_media_stream_dependency_factory.h"
+#include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
@@ -131,14 +133,16 @@ scoped_refptr<WebRtcAudioCapturer> CreateAudioCapturer(
 // 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,
+scoped_ptr<WebRtcLocalAudioTrack>
+CreateAndStartLocalAudioTrack(WebRtcLocalAudioTrackAdapter* adapter,
+                              WebRtcAudioCapturer* capturer,
                               PeerConnectionAudioSink* sink) {
-  scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
-      WebRtcLocalAudioTrack::Create(std::string(), capturer, NULL, NULL));
+  scoped_ptr<WebRtcLocalAudioTrack> local_audio_track(
+      new WebRtcLocalAudioTrack(adapter, capturer, NULL));
+
   local_audio_track->AddSink(sink);
   local_audio_track->Start();
-  return local_audio_track;
+  return local_audio_track.Pass();
 }
 
 class WebRTCMediaProcessImpl : public webrtc::VoEMediaProcess {
@@ -535,11 +539,14 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_StartPlayout) {
   EXPECT_EQ(0, external_media->RegisterExternalMediaProcessing(
       ch, webrtc::kPlaybackPerChannel, *media_process.get()));
 
+  scoped_refptr<webrtc::MediaStreamInterface> media_stream(
+      new talk_base::RefCountedObject<MockMediaStream>("label"));
+
   EXPECT_EQ(0, base->StartPlayout(ch));
   scoped_refptr<WebRtcAudioRenderer> renderer(
-      CreateDefaultWebRtcAudioRenderer(kRenderViewId));
+      CreateDefaultWebRtcAudioRenderer(kRenderViewId, media_stream));
   scoped_refptr<MediaStreamAudioRenderer> proxy(
-      renderer->CreateSharedAudioRendererProxy());
+      renderer->CreateSharedAudioRendererProxy(media_stream));
   EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   proxy->Start();
   proxy->Play();
@@ -641,11 +648,13 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_StartRecording) {
 
   // Create and start a local audio track which is bridging the data flow
   // between the capturer and WebRtcAudioDeviceImpl.
-  scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
-      CreateAndStartLocalAudioTrack(capturer, webrtc_audio_device));
+  scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
+      WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
+  scoped_ptr<WebRtcLocalAudioTrack> local_audio_track(
+      CreateAndStartLocalAudioTrack(adapter, capturer, webrtc_audio_device));
   // connect the VoE voice channel to the audio track
-  static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
-      GetRenderer()->AddChannel(ch);
+  static_cast<webrtc::AudioTrackInterface*>(
+      adapter.get())->GetRenderer()->AddChannel(ch);
 
   // Verify we get the data flow.
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_timeout()));
@@ -703,10 +712,12 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_PlayLocalFile) {
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
   EXPECT_EQ(0, base->StartPlayout(ch));
+  scoped_refptr<webrtc::MediaStreamInterface> media_stream(
+      new talk_base::RefCountedObject<MockMediaStream>("label"));
   scoped_refptr<WebRtcAudioRenderer> renderer(
-      CreateDefaultWebRtcAudioRenderer(kRenderViewId));
+      CreateDefaultWebRtcAudioRenderer(kRenderViewId, media_stream));
   scoped_refptr<MediaStreamAudioRenderer> proxy(
-      renderer->CreateSharedAudioRendererProxy());
+      renderer->CreateSharedAudioRendererProxy(media_stream));
   EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   proxy->Start();
   proxy->Play();
@@ -791,14 +802,16 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_FullDuplexAudioWithAGC) {
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
+  scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
+      WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
   scoped_refptr<WebRtcAudioCapturer> capturer(
       CreateAudioCapturer(webrtc_audio_device));
   EXPECT_TRUE(capturer);
-  scoped_refptr<WebRtcLocalAudioTrack> local_audio_track(
-      CreateAndStartLocalAudioTrack(capturer, webrtc_audio_device));
-  // connect the VoE voice channel to the audio track
-  static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
-      GetRenderer()->AddChannel(ch);
+  scoped_ptr<WebRtcLocalAudioTrack> local_audio_track(
+      CreateAndStartLocalAudioTrack(adapter, capturer, webrtc_audio_device));
+  // connect the VoE voice channel to the audio track adapter.
+  static_cast<webrtc::AudioTrackInterface*>(
+      adapter.get())->GetRenderer()->AddChannel(ch);
 
   ScopedWebRTCPtr<webrtc::VoENetwork> network(engine.get());
   ASSERT_TRUE(network.valid());
@@ -807,10 +820,12 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_FullDuplexAudioWithAGC) {
   EXPECT_EQ(0, network->RegisterExternalTransport(ch, *transport.get()));
   EXPECT_EQ(0, base->StartPlayout(ch));
   EXPECT_EQ(0, base->StartSend(ch));
+  scoped_refptr<webrtc::MediaStreamInterface> media_stream(
+      new talk_base::RefCountedObject<MockMediaStream>("label"));
   scoped_refptr<WebRtcAudioRenderer> renderer(
-      CreateDefaultWebRtcAudioRenderer(kRenderViewId));
+      CreateDefaultWebRtcAudioRenderer(kRenderViewId, media_stream));
   scoped_refptr<MediaStreamAudioRenderer> proxy(
-      renderer->CreateSharedAudioRendererProxy());
+      renderer->CreateSharedAudioRendererProxy(media_stream));
   EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
   proxy->Start();
   proxy->Play();
@@ -867,12 +882,14 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, DISABLED_WebRtcRecordingSetupTime) {
 
   // 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(capturer, sink.get()));
+  scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter(
+      WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL));
+  scoped_ptr<WebRtcLocalAudioTrack> local_audio_track(
+      CreateAndStartLocalAudioTrack(adapter, capturer, sink.get()));
 
-  // connect the VoE voice channel to the audio track.
-  static_cast<webrtc::AudioTrackInterface*>(local_audio_track.get())->
-      GetRenderer()->AddChannel(ch);
+  // connect the VoE voice channel to the audio track adapter.
+  static_cast<webrtc::AudioTrackInterface*>(
+      adapter.get())->GetRenderer()->AddChannel(ch);
 
   base::Time start_time = base::Time::Now();
   EXPECT_EQ(0, base->StartSend(ch));
@@ -912,11 +929,13 @@ TEST_F(MAYBE_WebRTCAudioDeviceTest, MAYBE_WebRtcPlayoutSetupTime) {
   scoped_ptr<MockWebRtcAudioRendererSource> renderer_source(
       new MockWebRtcAudioRendererSource(&event));
 
+  scoped_refptr<webrtc::MediaStreamInterface> media_stream(
+      new talk_base::RefCountedObject<MockMediaStream>("label"));
   scoped_refptr<WebRtcAudioRenderer> renderer(
-      CreateDefaultWebRtcAudioRenderer(kRenderViewId));
+      CreateDefaultWebRtcAudioRenderer(kRenderViewId, media_stream));
   renderer->Initialize(renderer_source.get());
   scoped_refptr<MediaStreamAudioRenderer> proxy(
-      renderer->CreateSharedAudioRendererProxy());
+      renderer->CreateSharedAudioRendererProxy(media_stream));
   proxy->Start();
 
   // Start the timer and playout.