Removing WebRTCAudioDeviceTest test suite

content/test/webrtc_audio_device_test.cc

Index: content/test/webrtc_audio_device_test.cc
diff --git a/content/test/webrtc_audio_device_test.cc b/content/test/webrtc_audio_device_test.cc
deleted file mode 100644
index 9d2d9da75ced19f17beb842b3c138bff842654c1..0000000000000000000000000000000000000000
--- a/content/test/webrtc_audio_device_test.cc
+++ /dev/null
@@ -1,454 +0,0 @@
-// 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 "content/test/webrtc_audio_device_test.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/compiler_specific.h"
-#include "base/file_util.h"
-#include "base/run_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/test/test_timeouts.h"
-#include "content/browser/media/capture/audio_mirroring_manager.h"
-#include "content/browser/media/media_internals.h"
-#include "content/browser/renderer_host/media/audio_input_renderer_host.h"
-#include "content/browser/renderer_host/media/audio_renderer_host.h"
-#include "content/browser/renderer_host/media/media_stream_manager.h"
-#include "content/browser/renderer_host/media/mock_media_observer.h"
-#include "content/common/media/media_param_traits.h"
-#include "content/common/view_messages.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/resource_context.h"
-#include "content/public/common/content_paths.h"
-#include "content/public/test/test_browser_thread.h"
-#include "content/renderer/media/audio_input_message_filter.h"
-#include "content/renderer/media/audio_message_filter.h"
-#include "content/renderer/media/webrtc_audio_device_impl.h"
-#include "content/renderer/render_process.h"
-#include "content/renderer/render_thread_impl.h"
-#include "content/renderer/renderer_webkitplatformsupport_impl.h"
-#include "media/audio/audio_parameters.h"
-#include "media/base/audio_hardware_config.h"
-#include "net/url_request/url_request_test_util.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/webrtc/voice_engine/include/voe_audio_processing.h"
-#include "third_party/webrtc/voice_engine/include/voe_base.h"
-#include "third_party/webrtc/voice_engine/include/voe_file.h"
-#include "third_party/webrtc/voice_engine/include/voe_network.h"
-
-#if defined(OS_WIN)
-#include "base/win/scoped_com_initializer.h"
-#endif
-
-using media::AudioParameters;
-using media::ChannelLayout;
-using testing::_;
-using testing::InvokeWithoutArgs;
-using testing::Return;
-using testing::StrEq;
-
-namespace content {
-
-// This class is a mock of the child process singleton which is needed
-// to be able to create a RenderThread object.
-class WebRTCMockRenderProcess : public RenderProcess {
- public:
-  WebRTCMockRenderProcess() {}
-  virtual ~WebRTCMockRenderProcess() {}
-
-  // RenderProcess implementation.
-  virtual skia::PlatformCanvas* GetDrawingCanvas(
-      TransportDIB** memory, const gfx::Rect& rect) OVERRIDE {
-    return NULL;
-  }
-  virtual void ReleaseTransportDIB(TransportDIB* memory) OVERRIDE {}
-  virtual void AddBindings(int bindings) OVERRIDE {}
-  virtual int GetEnabledBindings() const OVERRIDE { return 0; }
-  virtual TransportDIB* CreateTransportDIB(size_t size) OVERRIDE {
-    return NULL;
-  }
-  virtual void FreeTransportDIB(TransportDIB*) OVERRIDE {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(WebRTCMockRenderProcess);
-};
-
-class TestAudioRendererHost : public AudioRendererHost {
- public:
-  TestAudioRendererHost(
-      int render_process_id,
-      media::AudioManager* audio_manager,
-      AudioMirroringManager* mirroring_manager,
-      MediaInternals* media_internals,
-      MediaStreamManager* media_stream_manager,
-      IPC::Channel* channel)
-      : AudioRendererHost(render_process_id, audio_manager, mirroring_manager,
-                          media_internals, media_stream_manager),
-        channel_(channel) {}
-  virtual bool Send(IPC::Message* message) OVERRIDE {
-    if (channel_)
-      return channel_->Send(message);
-    return false;
-  }
-  void ResetChannel() {
-    channel_ = NULL;
-  }
-
- protected:
-  virtual ~TestAudioRendererHost() {}
-
- private:
-  IPC::Channel* channel_;
-};
-
-class TestAudioInputRendererHost : public AudioInputRendererHost {
- public:
-  TestAudioInputRendererHost(
-      media::AudioManager* audio_manager,
-      MediaStreamManager* media_stream_manager,
-      AudioMirroringManager* audio_mirroring_manager,
-      media::UserInputMonitor* user_input_monitor,
-      IPC::Channel* channel)
-      : AudioInputRendererHost(audio_manager, media_stream_manager,
-                               audio_mirroring_manager, user_input_monitor),
-        channel_(channel) {}
-  virtual bool Send(IPC::Message* message) OVERRIDE {
-    if (channel_)
-      return channel_->Send(message);
-    return false;
-  }
-  void ResetChannel() {
-    channel_ = NULL;
-  }
-
- protected:
-  virtual ~TestAudioInputRendererHost() {}
-
- private:
-  IPC::Channel* channel_;
-};
-
-// Utility scoped class to replace the global content client's renderer for the
-// duration of the test.
-class ReplaceContentClientRenderer {
- public:
-  explicit ReplaceContentClientRenderer(ContentRendererClient* new_renderer) {
-    saved_renderer_ = SetRendererClientForTesting(new_renderer);
-  }
-  ~ReplaceContentClientRenderer() {
-    // Restore the original renderer.
-    SetRendererClientForTesting(saved_renderer_);
-  }
- private:
-  ContentRendererClient* saved_renderer_;
-  DISALLOW_COPY_AND_ASSIGN(ReplaceContentClientRenderer);
-};
-
-class MockRTCResourceContext : public ResourceContext {
- public:
-  MockRTCResourceContext() : test_request_context_(NULL) {}
-  virtual ~MockRTCResourceContext() {}
-
-  void set_request_context(net::URLRequestContext* request_context) {
-    test_request_context_ = request_context;
-  }
-
-  // ResourceContext implementation:
-  virtual net::HostResolver* GetHostResolver() OVERRIDE {
-    return NULL;
-  }
-  virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
-    return test_request_context_;
-  }
-
-  virtual bool AllowMicAccess(const GURL& origin) OVERRIDE {
-    return false;
-  }
-
-  virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE {
-    return false;
-  }
-
- private:
-  net::URLRequestContext* test_request_context_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockRTCResourceContext);
-};
-
-ACTION_P(QuitMessageLoop, loop_or_proxy) {
-  loop_or_proxy->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
-}
-
-MAYBE_WebRTCAudioDeviceTest::MAYBE_WebRTCAudioDeviceTest()
-    : render_thread_(NULL), audio_hardware_config_(NULL),
-      has_input_devices_(false), has_output_devices_(false) {
-}
-
-MAYBE_WebRTCAudioDeviceTest::~MAYBE_WebRTCAudioDeviceTest() {}
-
-void MAYBE_WebRTCAudioDeviceTest::SetUp() {
-  // This part sets up a RenderThread environment to ensure that
-  // RenderThread::current() (<=> TLS pointer) is valid.
-  // Main parts are inspired by the RenderViewFakeResourcesTest.
-  // Note that, the IPC part is not utilized in this test.
-  saved_content_renderer_.reset(
-      new ReplaceContentClientRenderer(&content_renderer_client_));
-  mock_process_.reset(new WebRTCMockRenderProcess());
-  ui_thread_.reset(
-      new TestBrowserThread(BrowserThread::UI, base::MessageLoop::current()));
-
-  // Construct the resource context on the UI thread.
-  resource_context_.reset(new MockRTCResourceContext);
-
-  static const char kThreadName[] = "RenderThread";
-  ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
-      base::Bind(&MAYBE_WebRTCAudioDeviceTest::InitializeIOThread,
-                 base::Unretained(this), kThreadName));
-  WaitForIOThreadCompletion();
-
-  sandbox_was_enabled_ =
-      RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(false);
-  // TODO(tommi): RenderThreadImpl no longer supports being instantiated in
-  // tests like this.  Right now it initializes DiscardableMemory which can
-  // only be initialized once.  Since all WebRTCAudioDeviceTest have been
-  // disabled, they are starting to bit rot :-(
-  // We should use a mocked render thread.
-  render_thread_ = new RenderThreadImpl(kThreadName);
-}
-
-void MAYBE_WebRTCAudioDeviceTest::TearDown() {
-  SetAudioHardwareConfig(NULL);
-
-  // Run any pending cleanup tasks that may have been posted to the main thread.
-  base::RunLoop().RunUntilIdle();
-
-  // Kick of the cleanup process by closing the channel. This queues up
-  // OnStreamClosed calls to be executed on the audio thread.
-  ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
-      base::Bind(&MAYBE_WebRTCAudioDeviceTest::DestroyChannel,
-                 base::Unretained(this)));
-  WaitForIOThreadCompletion();
-
-  // When audio [input] render hosts are notified that the channel has
-  // been closed, they post tasks to the audio thread to close the
-  // AudioOutputController and once that's completed, a task is posted back to
-  // the IO thread to actually delete the AudioEntry for the audio stream. Only
-  // then is the reference to the audio manager released, so we wait for the
-  // whole thing to be torn down before we finally uninitialize the io thread.
-  WaitForAudioManagerCompletion();
-
-  ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
-      base::Bind(&MAYBE_WebRTCAudioDeviceTest::UninitializeIOThread,
-                 base::Unretained((this))));
-  WaitForIOThreadCompletion();
-  mock_process_.reset();
-  media_stream_manager_.reset();
-  mirroring_manager_.reset();
-  RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(
-      sandbox_was_enabled_);
-}
-
-bool MAYBE_WebRTCAudioDeviceTest::Send(IPC::Message* message) {
-  return channel_->Send(message);
-}
-
-void MAYBE_WebRTCAudioDeviceTest::SetAudioHardwareConfig(
-    media::AudioHardwareConfig* hardware_config) {
-  audio_hardware_config_ = hardware_config;
-}
-
-scoped_refptr<WebRtcAudioRenderer>
-MAYBE_WebRTCAudioDeviceTest::CreateDefaultWebRtcAudioRenderer(
-    int render_view_id,
-    const scoped_refptr<webrtc::MediaStreamInterface>& media_stream) {
-  media::AudioHardwareConfig* hardware_config =
-      RenderThreadImpl::current()->GetAudioHardwareConfig();
-  int sample_rate = hardware_config->GetOutputSampleRate();
-  int frames_per_buffer = hardware_config->GetOutputBufferSize();
-  return new WebRtcAudioRenderer(media_stream, render_view_id, MSG_ROUTING_NONE,
-                                 0, sample_rate, frames_per_buffer);
-}
-
-void MAYBE_WebRTCAudioDeviceTest::InitializeIOThread(const char* thread_name) {
-#if defined(OS_WIN)
-  // We initialize COM (STA) on our IO thread as is done in Chrome.
-  // See BrowserProcessSubThread::Init.
-  initialize_com_.reset(new base::win::ScopedCOMInitializer());
-#endif
-
-  // Set the current thread as the IO thread.
-  io_thread_.reset(
-      new TestBrowserThread(BrowserThread::IO, base::MessageLoop::current()));
-
-  // Populate our resource context.
-  test_request_context_.reset(new net::TestURLRequestContext());
-  MockRTCResourceContext* resource_context =
-      static_cast<MockRTCResourceContext*>(resource_context_.get());
-  resource_context->set_request_context(test_request_context_.get());
-
-  // Create our own AudioManager, AudioMirroringManager and MediaStreamManager.
-  audio_manager_.reset(media::AudioManager::CreateForTesting());
-  mirroring_manager_.reset(new AudioMirroringManager());
-  media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
-
-  has_input_devices_ = audio_manager_->HasAudioInputDevices();
-  has_output_devices_ = audio_manager_->HasAudioOutputDevices();
-
-  // Create an IPC channel that handles incoming messages on the IO thread.
-  CreateChannel(thread_name);
-}
-
-void MAYBE_WebRTCAudioDeviceTest::UninitializeIOThread() {
-  resource_context_.reset();
-
-  test_request_context_.reset();
-
-#if defined(OS_WIN)
-  initialize_com_.reset();
-#endif
-
-  audio_manager_.reset();
-}
-
-void MAYBE_WebRTCAudioDeviceTest::CreateChannel(const char* name) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  channel_.reset(new IPC::Channel(name, IPC::Channel::MODE_SERVER, this));
-  ASSERT_TRUE(channel_->Connect());
-
-  static const int kRenderProcessId = 1;
-  audio_render_host_ = new TestAudioRendererHost(kRenderProcessId,
-                                                 audio_manager_.get(),
-                                                 mirroring_manager_.get(),
-                                                 MediaInternals::GetInstance(),
-                                                 media_stream_manager_.get(),
-                                                 channel_.get());
-  audio_render_host_->set_peer_pid_for_testing(base::GetCurrentProcId());
-
-  audio_input_renderer_host_ =
-      new TestAudioInputRendererHost(audio_manager_.get(),
-                                     media_stream_manager_.get(),
-                                     mirroring_manager_.get(),
-                                     NULL,
-                                     channel_.get());
-  audio_input_renderer_host_->set_peer_pid_for_testing(
-      base::GetCurrentProcId());
-}
-
-void MAYBE_WebRTCAudioDeviceTest::DestroyChannel() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  audio_render_host_->OnChannelClosing();
-  audio_render_host_->OnFilterRemoved();
-  audio_input_renderer_host_->OnChannelClosing();
-  audio_input_renderer_host_->OnFilterRemoved();
-  audio_render_host_->ResetChannel();
-  audio_input_renderer_host_->ResetChannel();
-  channel_.reset();
-  audio_render_host_ = NULL;
-  audio_input_renderer_host_ = NULL;
-}
-
-void MAYBE_WebRTCAudioDeviceTest::OnGetAudioHardwareConfig(
-    AudioParameters* input_params, AudioParameters* output_params) {
-  ASSERT_TRUE(audio_hardware_config_);
-  *input_params = audio_hardware_config_->GetInputConfig();
-  *output_params = audio_hardware_config_->GetOutputConfig();
-}
-
-// IPC::Listener implementation.
-bool MAYBE_WebRTCAudioDeviceTest::OnMessageReceived(
-    const IPC::Message& message) {
-  if (render_thread_) {
-    IPC::ChannelProxy::MessageFilter* filter =
-        render_thread_->audio_input_message_filter();
-    if (filter->OnMessageReceived(message))
-      return true;
-
-    filter = render_thread_->audio_message_filter();
-    if (filter->OnMessageReceived(message))
-      return true;
-  }
-
-  if (audio_render_host_.get()) {
-    bool message_was_ok = false;
-    if (audio_render_host_->OnMessageReceived(message, &message_was_ok))
-      return true;
-  }
-
-  if (audio_input_renderer_host_.get()) {
-    bool message_was_ok = false;
-    if (audio_input_renderer_host_->OnMessageReceived(message, &message_was_ok))
-      return true;
-  }
-
-  bool handled ALLOW_UNUSED = true;
-  bool message_is_ok = true;
-  IPC_BEGIN_MESSAGE_MAP_EX(MAYBE_WebRTCAudioDeviceTest, message, message_is_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioHardwareConfig,
-                        OnGetAudioHardwareConfig)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP_EX()
-
-  EXPECT_TRUE(message_is_ok);
-
-  return true;
-}
-
-// Posts a final task to the IO message loop and waits for completion.
-void MAYBE_WebRTCAudioDeviceTest::WaitForIOThreadCompletion() {
-  WaitForTaskRunnerCompletion(
-      ChildProcess::current()->io_message_loop()->message_loop_proxy());
-}
-
-void MAYBE_WebRTCAudioDeviceTest::WaitForAudioManagerCompletion() {
-  if (audio_manager_)
-    WaitForTaskRunnerCompletion(audio_manager_->GetTaskRunner());
-}
-
-void MAYBE_WebRTCAudioDeviceTest::WaitForTaskRunnerCompletion(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
-  base::WaitableEvent* event = new base::WaitableEvent(false, false);
-  task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&base::WaitableEvent::Signal, base::Unretained(event)));
-  if (event->TimedWait(TestTimeouts::action_max_timeout())) {
-    delete event;
-  } else {
-    // Don't delete the event object in case the message ever gets processed.
-    // If we do, we will crash the test process.
-    ADD_FAILURE() << "Failed to wait for message loop";
-  }
-}
-
-std::string MAYBE_WebRTCAudioDeviceTest::GetTestDataPath(
-    const base::FilePath::StringType& file_name) {
-  base::FilePath path;
-  EXPECT_TRUE(PathService::Get(DIR_TEST_DATA, &path));
-  path = path.Append(file_name);
-  EXPECT_TRUE(base::PathExists(path));
-#if defined(OS_WIN)
-  return base::WideToUTF8(path.value());
-#else
-  return path.value();
-#endif
-}
-
-WebRTCTransportImpl::WebRTCTransportImpl(webrtc::VoENetwork* network)
-    : network_(network) {
-}
-
-WebRTCTransportImpl::~WebRTCTransportImpl() {}
-
-int WebRTCTransportImpl::SendPacket(int channel, const void* data, int len) {
-  return network_->ReceivedRTPPacket(channel, data, len);
-}
-
-int WebRTCTransportImpl::SendRTCPPacket(int channel, const void* data,
-                                        int len) {
-  return network_->ReceivedRTCPPacket(channel, data, len);
-}
-
-}  // namespace content