content/test/webrtc_audio_device_test.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/test/webrtc_audio_device_test.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/file_util.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/run_loop.h"
  13 #include "base/synchronization/waitable_event.h"
  14 #include "base/test/test_timeouts.h"
  15 #include "content/browser/renderer_host/media/audio_input_renderer_host.h"
  16 #include "content/browser/renderer_host/media/audio_mirroring_manager.h"
  17 #include "content/browser/renderer_host/media/audio_renderer_host.h"
  18 #include "content/browser/renderer_host/media/media_stream_manager.h"
  19 #include "content/browser/renderer_host/media/mock_media_observer.h"
  20 #include "content/common/media/media_param_traits.h"
  21 #include "content/common/view_messages.h"
  22 #include "content/public/browser/browser_thread.h"
  23 #include "content/public/browser/resource_context.h"
  24 #include "content/public/common/content_paths.h"
  25 #include "content/public/test/test_browser_thread.h"
  26 #include "content/renderer/media/audio_input_message_filter.h"
  27 #include "content/renderer/media/audio_message_filter.h"
  28 #include "content/renderer/media/webrtc_audio_device_impl.h"
  29 #include "content/renderer/render_process.h"
  30 #include "content/renderer/render_thread_impl.h"
  31 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
  32 #include "media/audio/audio_parameters.h"
  33 #include "media/base/audio_hardware_config.h"
  34 #include "net/url_request/url_request_test_util.h"
  35 #include "testing/gmock/include/gmock/gmock.h"
  36 #include "testing/gtest/include/gtest/gtest.h"
  37 #include "third_party/webrtc/voice_engine/include/voe_audio_processing.h"
  38 #include "third_party/webrtc/voice_engine/include/voe_base.h"
  39 #include "third_party/webrtc/voice_engine/include/voe_file.h"
  40 #include "third_party/webrtc/voice_engine/include/voe_network.h"
  41
  42 #if defined(OS_WIN)
  43 #include "base/win/scoped_com_initializer.h"
  44 #endif
  45
  46 using media::AudioParameters;
  47 using media::ChannelLayout;
  48 using testing::_;
  49 using testing::InvokeWithoutArgs;
  50 using testing::Return;
  51 using testing::StrEq;
  52
  53 namespace content {
  54
  55 // This class is a mock of the child process singleton which is needed
  56 // to be able to create a RenderThread object.
  57 class WebRTCMockRenderProcess : public RenderProcess {
  58  public:
  59   WebRTCMockRenderProcess() {}
  60   virtual ~WebRTCMockRenderProcess() {}
  61
  62   // RenderProcess implementation.
  63   virtual skia::PlatformCanvas* GetDrawingCanvas(
  64       TransportDIB** memory, const gfx::Rect& rect) OVERRIDE {
  65     return NULL;
  66   }
  67   virtual void ReleaseTransportDIB(TransportDIB* memory) OVERRIDE {}
  68   virtual bool UseInProcessPlugins() const OVERRIDE { return false; }
  69   virtual void AddBindings(int bindings) OVERRIDE {}
  70   virtual int GetEnabledBindings() const OVERRIDE { return 0; }
  71   virtual TransportDIB* CreateTransportDIB(size_t size) OVERRIDE {
  72     return NULL;
  73   }
  74   virtual void FreeTransportDIB(TransportDIB*) OVERRIDE {}
  75
  76  private:
  77   DISALLOW_COPY_AND_ASSIGN(WebRTCMockRenderProcess);
  78 };
  79
  80 // Utility scoped class to replace the global content client's renderer for the
  81 // duration of the test.
  82 class ReplaceContentClientRenderer {
  83  public:
  84   explicit ReplaceContentClientRenderer(ContentRendererClient* new_renderer) {
  85     saved_renderer_ = SetRendererClientForTesting(new_renderer);
  86   }
  87   ~ReplaceContentClientRenderer() {
  88     // Restore the original renderer.
  89     SetRendererClientForTesting(saved_renderer_);
  90   }
  91  private:
  92   ContentRendererClient* saved_renderer_;
  93   DISALLOW_COPY_AND_ASSIGN(ReplaceContentClientRenderer);
  94 };
  95
  96 class MockRTCResourceContext : public ResourceContext {
  97  public:
  98   MockRTCResourceContext() : test_request_context_(NULL) {}
  99   virtual ~MockRTCResourceContext() {}
 100
 101   void set_request_context(net::URLRequestContext* request_context) {
 102     test_request_context_ = request_context;
 103   }
 104
 105   // ResourceContext implementation:
 106   virtual net::HostResolver* GetHostResolver() OVERRIDE {
 107     return NULL;
 108   }
 109   virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
 110     return test_request_context_;
 111   }
 112
 113   virtual bool AllowMicAccess(const GURL& origin) OVERRIDE {
 114     return false;
 115   }
 116
 117   virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE {
 118     return false;
 119   }
 120
 121  private:
 122   net::URLRequestContext* test_request_context_;
 123
 124   DISALLOW_COPY_AND_ASSIGN(MockRTCResourceContext);
 125 };
 126
 127 ACTION_P(QuitMessageLoop, loop_or_proxy) {
 128   loop_or_proxy->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 129 }
 130
 131 MAYBE_WebRTCAudioDeviceTest::MAYBE_WebRTCAudioDeviceTest()
 132     : render_thread_(NULL), audio_hardware_config_(NULL),
 133       has_input_devices_(false), has_output_devices_(false) {
 134 }
 135
 136 MAYBE_WebRTCAudioDeviceTest::~MAYBE_WebRTCAudioDeviceTest() {}
 137
 138 void MAYBE_WebRTCAudioDeviceTest::SetUp() {
 139   // This part sets up a RenderThread environment to ensure that
 140   // RenderThread::current() (<=> TLS pointer) is valid.
 141   // Main parts are inspired by the RenderViewFakeResourcesTest.
 142   // Note that, the IPC part is not utilized in this test.
 143   saved_content_renderer_.reset(
 144       new ReplaceContentClientRenderer(&content_renderer_client_));
 145   mock_process_.reset(new WebRTCMockRenderProcess());
 146   ui_thread_.reset(
 147       new TestBrowserThread(BrowserThread::UI, base::MessageLoop::current()));
 148
 149   // Construct the resource context on the UI thread.
 150   resource_context_.reset(new MockRTCResourceContext);
 151
 152   static const char kThreadName[] = "RenderThread";
 153   ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
 154       base::Bind(&MAYBE_WebRTCAudioDeviceTest::InitializeIOThread,
 155                  base::Unretained(this), kThreadName));
 156   WaitForIOThreadCompletion();
 157
 158   sandbox_was_enabled_ =
 159       RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(false);
 160   render_thread_ = new RenderThreadImpl(kThreadName);
 161 }
 162
 163 void MAYBE_WebRTCAudioDeviceTest::TearDown() {
 164   SetAudioHardwareConfig(NULL);
 165
 166   // Run any pending cleanup tasks that may have been posted to the main thread.
 167   base::RunLoop().RunUntilIdle();
 168
 169   // Kick of the cleanup process by closing the channel. This queues up
 170   // OnStreamClosed calls to be executed on the audio thread.
 171   ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
 172       base::Bind(&MAYBE_WebRTCAudioDeviceTest::DestroyChannel,
 173                  base::Unretained(this)));
 174   WaitForIOThreadCompletion();
 175
 176   // When audio [input] render hosts are notified that the channel has
 177   // been closed, they post tasks to the audio thread to close the
 178   // AudioOutputController and once that's completed, a task is posted back to
 179   // the IO thread to actually delete the AudioEntry for the audio stream. Only
 180   // then is the reference to the audio manager released, so we wait for the
 181   // whole thing to be torn down before we finally uninitialize the io thread.
 182   WaitForAudioManagerCompletion();
 183
 184   ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
 185       base::Bind(&MAYBE_WebRTCAudioDeviceTest::UninitializeIOThread,
 186                  base::Unretained((this))));
 187   WaitForIOThreadCompletion();
 188   mock_process_.reset();
 189   media_stream_manager_.reset();
 190   mirroring_manager_.reset();
 191   RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(
 192       sandbox_was_enabled_);
 193 }
 194
 195 bool MAYBE_WebRTCAudioDeviceTest::Send(IPC::Message* message) {
 196   return channel_->Send(message);
 197 }
 198
 199 void MAYBE_WebRTCAudioDeviceTest::SetAudioHardwareConfig(
 200     media::AudioHardwareConfig* hardware_config) {
 201   audio_hardware_config_ = hardware_config;
 202 }
 203
 204 scoped_refptr<WebRtcAudioRenderer>
 205 MAYBE_WebRTCAudioDeviceTest::CreateDefaultWebRtcAudioRenderer(
 206     int render_view_id) {
 207   media::AudioHardwareConfig* hardware_config =
 208       RenderThreadImpl::current()->GetAudioHardwareConfig();
 209   int sample_rate = hardware_config->GetOutputSampleRate();
 210   int frames_per_buffer = hardware_config->GetOutputBufferSize();
 211
 212   return new WebRtcAudioRenderer(render_view_id, 0, sample_rate,
 213                                  frames_per_buffer);
 214 }
 215
 216 void MAYBE_WebRTCAudioDeviceTest::InitializeIOThread(const char* thread_name) {
 217 #if defined(OS_WIN)
 218   // We initialize COM (STA) on our IO thread as is done in Chrome.
 219   // See BrowserProcessSubThread::Init.
 220   initialize_com_.reset(new base::win::ScopedCOMInitializer());
 221 #endif
 222
 223   // Set the current thread as the IO thread.
 224   io_thread_.reset(
 225       new TestBrowserThread(BrowserThread::IO, base::MessageLoop::current()));
 226
 227   // Populate our resource context.
 228   test_request_context_.reset(new net::TestURLRequestContext());
 229   MockRTCResourceContext* resource_context =
 230       static_cast<MockRTCResourceContext*>(resource_context_.get());
 231   resource_context->set_request_context(test_request_context_.get());
 232   media_internals_.reset(new MockMediaInternals());
 233
 234   // Create our own AudioManager, AudioMirroringManager and MediaStreamManager.
 235   audio_manager_.reset(media::AudioManager::Create());
 236   mirroring_manager_.reset(new AudioMirroringManager());
 237   media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
 238
 239   has_input_devices_ = audio_manager_->HasAudioInputDevices();
 240   has_output_devices_ = audio_manager_->HasAudioOutputDevices();
 241
 242   // Create an IPC channel that handles incoming messages on the IO thread.
 243   CreateChannel(thread_name);
 244 }
 245
 246 void MAYBE_WebRTCAudioDeviceTest::UninitializeIOThread() {
 247   resource_context_.reset();
 248
 249   test_request_context_.reset();
 250
 251 #if defined(OS_WIN)
 252   initialize_com_.reset();
 253 #endif
 254
 255   audio_manager_.reset();
 256 }
 257
 258 void MAYBE_WebRTCAudioDeviceTest::CreateChannel(const char* name) {
 259   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 260
 261   static const int kRenderProcessId = 1;
 262   audio_render_host_ = new AudioRendererHost(
 263       kRenderProcessId, audio_manager_.get(), mirroring_manager_.get(),
 264       media_internals_.get(), media_stream_manager_.get());
 265   audio_render_host_->OnChannelConnected(base::GetCurrentProcId());
 266
 267   audio_input_renderer_host_ =
 268       new AudioInputRendererHost(audio_manager_.get(),
 269                                  media_stream_manager_.get(),
 270                                  mirroring_manager_.get(),
 271                                  NULL);
 272   audio_input_renderer_host_->OnChannelConnected(base::GetCurrentProcId());
 273
 274   channel_.reset(new IPC::Channel(name, IPC::Channel::MODE_SERVER, this));
 275   ASSERT_TRUE(channel_->Connect());
 276
 277   audio_render_host_->OnFilterAdded(channel_.get());
 278   audio_input_renderer_host_->OnFilterAdded(channel_.get());
 279 }
 280
 281 void MAYBE_WebRTCAudioDeviceTest::DestroyChannel() {
 282   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 283   audio_render_host_->OnChannelClosing();
 284   audio_render_host_->OnFilterRemoved();
 285   audio_input_renderer_host_->OnChannelClosing();
 286   audio_input_renderer_host_->OnFilterRemoved();
 287   channel_.reset();
 288   audio_render_host_ = NULL;
 289   audio_input_renderer_host_ = NULL;
 290 }
 291
 292 void MAYBE_WebRTCAudioDeviceTest::OnGetAudioHardwareConfig(
 293     AudioParameters* input_params, AudioParameters* output_params) {
 294   ASSERT_TRUE(audio_hardware_config_);
 295   *input_params = audio_hardware_config_->GetInputConfig();
 296   *output_params = audio_hardware_config_->GetOutputConfig();
 297 }
 298
 299 // IPC::Listener implementation.
 300 bool MAYBE_WebRTCAudioDeviceTest::OnMessageReceived(
 301     const IPC::Message& message) {
 302   if (render_thread_) {
 303     IPC::ChannelProxy::MessageFilter* filter =
 304         render_thread_->audio_input_message_filter();
 305     if (filter->OnMessageReceived(message))
 306       return true;
 307
 308     filter = render_thread_->audio_message_filter();
 309     if (filter->OnMessageReceived(message))
 310       return true;
 311   }
 312
 313   if (audio_render_host_.get()) {
 314     bool message_was_ok = false;
 315     if (audio_render_host_->OnMessageReceived(message, &message_was_ok))
 316       return true;
 317   }
 318
 319   if (audio_input_renderer_host_.get()) {
 320     bool message_was_ok = false;
 321     if (audio_input_renderer_host_->OnMessageReceived(message, &message_was_ok))
 322       return true;
 323   }
 324
 325   bool handled ALLOW_UNUSED = true;
 326   bool message_is_ok = true;
 327   IPC_BEGIN_MESSAGE_MAP_EX(MAYBE_WebRTCAudioDeviceTest, message, message_is_ok)
 328     IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioHardwareConfig,
 329                         OnGetAudioHardwareConfig)
 330     IPC_MESSAGE_UNHANDLED(handled = false)
 331   IPC_END_MESSAGE_MAP_EX()
 332
 333   EXPECT_TRUE(message_is_ok);
 334
 335   return true;
 336 }
 337
 338 // Posts a final task to the IO message loop and waits for completion.
 339 void MAYBE_WebRTCAudioDeviceTest::WaitForIOThreadCompletion() {
 340   WaitForMessageLoopCompletion(
 341       ChildProcess::current()->io_message_loop()->message_loop_proxy().get());
 342 }
 343
 344 void MAYBE_WebRTCAudioDeviceTest::WaitForAudioManagerCompletion() {
 345   if (audio_manager_)
 346     WaitForMessageLoopCompletion(audio_manager_->GetMessageLoop().get());
 347 }
 348
 349 void MAYBE_WebRTCAudioDeviceTest::WaitForMessageLoopCompletion(
 350     base::MessageLoopProxy* loop) {
 351   base::WaitableEvent* event = new base::WaitableEvent(false, false);
 352   loop->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
 353                  base::Unretained(event)));
 354   if (event->TimedWait(TestTimeouts::action_max_timeout())) {
 355     delete event;
 356   } else {
 357     // Don't delete the event object in case the message ever gets processed.
 358     // If we do, we will crash the test process.
 359     ADD_FAILURE() << "Failed to wait for message loop";
 360   }
 361 }
 362
 363 std::string MAYBE_WebRTCAudioDeviceTest::GetTestDataPath(
 364     const base::FilePath::StringType& file_name) {
 365   base::FilePath path;
 366   EXPECT_TRUE(PathService::Get(DIR_TEST_DATA, &path));
 367   path = path.Append(file_name);
 368   EXPECT_TRUE(base::PathExists(path));
 369 #if defined(OS_WIN)
 370   return WideToUTF8(path.value());
 371 #else
 372   return path.value();
 373 #endif
 374 }
 375
 376 WebRTCTransportImpl::WebRTCTransportImpl(webrtc::VoENetwork* network)
 377     : network_(network) {
 378 }
 379
 380 WebRTCTransportImpl::~WebRTCTransportImpl() {}
 381
 382 int WebRTCTransportImpl::SendPacket(int channel, const void* data, int len) {
 383   return network_->ReceivedRTPPacket(channel, data, len);
 384 }
 385
 386 int WebRTCTransportImpl::SendRTCPPacket(int channel, const void* data,
 387                                         int len) {
 388   return network_->ReceivedRTCPPacket(channel, data, len);
 389 }
 390
 391 }  // namespace content