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.
5 #ifndef CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
6 #define CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_
10 #include "base/files/file_path.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "content/browser/renderer_host/media/mock_media_observer.h"
14 #include "content/public/renderer/content_renderer_client.h"
15 #include "ipc/ipc_listener.h"
16 #include "media/base/audio_hardware_config.h"
17 #include "media/base/channel_layout.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19 #include "third_party/webrtc/common_types.h"
30 class URLRequestContext;
34 class MediaStreamInterface;
41 class ScopedCOMInitializer;
48 class AudioMirroringManager;
49 class ContentRendererClient;
50 class MediaStreamManager;
51 class RenderThreadImpl;
52 class ResourceContext;
53 class TestAudioInputRendererHost;
54 class TestAudioRendererHost;
55 class TestBrowserThread;
56 class WebRtcAudioRenderer;
57 class WebRTCMockRenderProcess;
59 // Scoped class for WebRTC interfaces. Fetches the wrapped interface
60 // in the constructor via WebRTC's GetInterface mechanism and then releases
61 // the reference in the destructor.
63 class ScopedWebRTCPtr {
65 template<typename Engine>
66 explicit ScopedWebRTCPtr(Engine* e)
67 : ptr_(T::GetInterface(e)) {}
68 explicit ScopedWebRTCPtr(T* p) : ptr_(p) {}
69 ~ScopedWebRTCPtr() { reset(); }
70 T* operator->() const { return ptr_; }
71 T* get() const { return ptr_; }
73 // Releases the current pointer.
81 bool valid() const { return ptr_ != NULL; }
87 // Wrapper to automatically calling T::Delete in the destructor.
88 // This is useful for some WebRTC objects that have their own Create/Delete
89 // methods and we can't use our our scoped_* classes.
91 class WebRTCAutoDelete {
93 WebRTCAutoDelete() : ptr_(NULL) {}
94 explicit WebRTCAutoDelete(T* ptr) : ptr_(ptr) {}
95 ~WebRTCAutoDelete() { reset(); }
104 T* operator->() { return ptr_; }
105 T* get() const { return ptr_; }
107 bool valid() const { return ptr_ != NULL; }
113 // Implemented and defined in the cc file.
114 class ReplaceContentClientRenderer;
116 // Temporarily disabled in LeakSanitizer builds due to memory leaks.
117 // http://crbug.com/148865
118 // Disabling all tests for now since they are flaky.
119 // http://crbug.com/167298
120 #define MAYBE_WebRTCAudioDeviceTest DISABLED_WebRTCAudioDeviceTest
122 class MAYBE_WebRTCAudioDeviceTest : public ::testing::Test,
123 public IPC::Listener {
125 MAYBE_WebRTCAudioDeviceTest();
126 virtual ~MAYBE_WebRTCAudioDeviceTest();
128 virtual void SetUp() OVERRIDE;
129 virtual void TearDown() OVERRIDE;
131 // Sends an IPC message to the IO thread channel.
132 bool Send(IPC::Message* message);
134 void SetAudioHardwareConfig(media::AudioHardwareConfig* hardware_config);
136 scoped_refptr<WebRtcAudioRenderer> CreateDefaultWebRtcAudioRenderer(
138 const scoped_refptr<webrtc::MediaStreamInterface>& media_stream);
141 void InitializeIOThread(const char* thread_name);
142 void UninitializeIOThread();
143 void CreateChannel(const char* name);
144 void DestroyChannel();
146 void OnGetAudioHardwareConfig(media::AudioParameters* input_params,
147 media::AudioParameters* output_params);
149 // IPC::Listener implementation.
150 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
152 // Posts a final task to the IO message loop and waits for completion.
153 void WaitForIOThreadCompletion();
154 void WaitForAudioManagerCompletion();
155 void WaitForTaskRunnerCompletion(
156 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
158 std::string GetTestDataPath(const base::FilePath::StringType& file_name);
160 scoped_ptr<ReplaceContentClientRenderer> saved_content_renderer_;
161 base::MessageLoopForUI message_loop_;
162 ContentRendererClient content_renderer_client_;
163 RenderThreadImpl* render_thread_; // Owned by mock_process_.
164 scoped_ptr<WebRTCMockRenderProcess> mock_process_;
165 scoped_ptr<MediaStreamManager> media_stream_manager_;
166 scoped_ptr<media::AudioManager> audio_manager_;
167 scoped_ptr<AudioMirroringManager> mirroring_manager_;
168 scoped_ptr<net::URLRequestContext> test_request_context_;
169 scoped_ptr<ResourceContext> resource_context_;
170 scoped_ptr<IPC::Channel> channel_;
171 scoped_refptr<TestAudioRendererHost> audio_render_host_;
172 scoped_refptr<TestAudioInputRendererHost> audio_input_renderer_host_;
174 media::AudioHardwareConfig* audio_hardware_config_; // Weak reference.
176 // Initialized on the main test thread that we mark as the UI thread.
177 scoped_ptr<TestBrowserThread> ui_thread_;
178 // Initialized on our IO thread to satisfy BrowserThread::IO checks.
179 scoped_ptr<TestBrowserThread> io_thread_;
182 // COM initialization on the IO thread.
183 scoped_ptr<base::win::ScopedCOMInitializer> initialize_com_;
186 // These are initialized when we set up our IO thread.
187 bool has_input_devices_;
188 bool has_output_devices_;
190 // The previous state for whether sandbox support was enabled in
191 // RenderViewWebKitPlatformSupportImpl.
192 bool sandbox_was_enabled_;
195 // A very basic implementation of webrtc::Transport that acts as a transport
196 // but just forwards all calls to a local webrtc::VoENetwork implementation.
197 // Ownership of the VoENetwork object lies outside the class.
198 class WebRTCTransportImpl : public webrtc::Transport {
200 explicit WebRTCTransportImpl(webrtc::VoENetwork* network);
201 virtual ~WebRTCTransportImpl();
203 virtual int SendPacket(int channel, const void* data, int len) OVERRIDE;
204 virtual int SendRTCPPacket(int channel, const void* data, int len) OVERRIDE;
207 webrtc::VoENetwork* network_;
210 } // namespace content
212 #endif // CONTENT_TEST_WEBRTC_AUDIO_DEVICE_TEST_H_