OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/renderer_host/media/audio_output_delegate_impl.h" | 5 #include "content/browser/renderer_host/media/audio_output_delegate_impl.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
11 | 11 |
12 #include "base/bind.h" | 12 #include "base/bind.h" |
13 #include "base/command_line.h" | 13 #include "base/command_line.h" |
14 #include "base/memory/ptr_util.h" | 14 #include "base/memory/ptr_util.h" |
15 #include "base/message_loop/message_loop.h" | 15 #include "base/message_loop/message_loop.h" |
16 #include "base/run_loop.h" | 16 #include "base/run_loop.h" |
| 17 #include "base/sync_socket.h" |
17 #include "content/browser/audio_manager_thread.h" | 18 #include "content/browser/audio_manager_thread.h" |
18 #include "content/browser/media/capture/audio_mirroring_manager.h" | 19 #include "content/browser/media/capture/audio_mirroring_manager.h" |
19 #include "content/public/browser/browser_thread.h" | 20 #include "content/public/browser/browser_thread.h" |
20 #include "content/public/browser/media_observer.h" | 21 #include "content/public/browser/media_observer.h" |
21 #include "content/public/test/test_browser_thread_bundle.h" | 22 #include "content/public/test/test_browser_thread_bundle.h" |
22 #include "media/audio/audio_output_controller.h" | 23 #include "media/audio/audio_output_controller.h" |
23 #include "media/audio/fake_audio_log_factory.h" | 24 #include "media/audio/fake_audio_log_factory.h" |
24 #include "media/audio/fake_audio_manager.h" | 25 #include "media/audio/fake_audio_manager.h" |
25 #include "media/base/media_switches.h" | 26 #include "media/base/media_switches.h" |
26 #include "testing/gmock/include/gmock/gmock.h" | 27 #include "testing/gmock/include/gmock/gmock.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
64 int page_request_id, | 65 int page_request_id, |
65 MediaStreamType stream_type, | 66 MediaStreamType stream_type, |
66 bool is_secure) override {} | 67 bool is_secure) override {} |
67 | 68 |
68 MOCK_METHOD2(OnCreatingAudioStream, | 69 MOCK_METHOD2(OnCreatingAudioStream, |
69 void(int render_process_id, int render_frame_id)); | 70 void(int render_process_id, int render_frame_id)); |
70 }; | 71 }; |
71 | 72 |
72 class MockEventHandler : public media::AudioOutputDelegate::EventHandler { | 73 class MockEventHandler : public media::AudioOutputDelegate::EventHandler { |
73 public: | 74 public: |
74 MOCK_METHOD3(OnStreamCreated, | 75 void OnStreamCreated(int stream_id, |
75 void(int stream_id, | 76 base::SharedMemory* shared_memory, |
76 base::SharedMemory* shared_memory, | 77 std::unique_ptr<base::CancelableSyncSocket> socket) { |
77 base::CancelableSyncSocket* socket)); | 78 EXPECT_EQ(stream_id, kStreamId); |
| 79 EXPECT_NE(shared_memory, nullptr); |
| 80 EXPECT_NE(socket.get(), nullptr); |
| 81 GotOnStreamCreated(); |
| 82 } |
| 83 |
| 84 MOCK_METHOD0(GotOnStreamCreated, void()); |
78 MOCK_METHOD1(OnStreamError, void(int stream_id)); | 85 MOCK_METHOD1(OnStreamError, void(int stream_id)); |
79 }; | 86 }; |
80 | 87 |
81 class DummyAudioOutputStream : public media::AudioOutputStream { | 88 class DummyAudioOutputStream : public media::AudioOutputStream { |
82 public: | 89 public: |
83 // AudioOutputSteam implementation: | 90 // AudioOutputSteam implementation: |
84 bool Open() override { return true; } | 91 bool Open() override { return true; } |
85 void Start(AudioSourceCallback* cb) override {} | 92 void Start(AudioSourceCallback* cb) override {} |
86 void Stop() override {} | 93 void Stop() override {} |
87 void SetVolume(double volume) override {} | 94 void SetVolume(double volume) override {} |
(...skipping 19 matching lines...) Expand all Loading... |
107 | 114 |
108 audio_manager_.reset(new media::FakeAudioManager( | 115 audio_manager_.reset(new media::FakeAudioManager( |
109 audio_thread_->task_runner(), audio_thread_->worker_task_runner(), | 116 audio_thread_->task_runner(), audio_thread_->worker_task_runner(), |
110 &log_factory_)); | 117 &log_factory_)); |
111 } | 118 } |
112 | 119 |
113 // Test bodies are here, so that we can run them on the IO thread. | 120 // Test bodies are here, so that we can run them on the IO thread. |
114 void CreateTest(base::Closure done) { | 121 void CreateTest(base::Closure done) { |
115 EXPECT_CALL(media_observer_, | 122 EXPECT_CALL(media_observer_, |
116 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 123 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
117 EXPECT_CALL(event_handler_, | 124 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
118 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
119 EXPECT_CALL(mirroring_manager_, | 125 EXPECT_CALL(mirroring_manager_, |
120 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 126 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
121 | 127 |
122 { | 128 { |
123 AudioOutputDelegateImpl delegate( | 129 AudioOutputDelegateImpl delegate( |
124 &event_handler_, audio_manager_.get(), | 130 &event_handler_, audio_manager_.get(), |
125 log_factory_.CreateAudioLog( | 131 log_factory_.CreateAudioLog( |
126 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 132 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
127 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 133 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
128 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 134 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
129 kDefaultDeviceId); | 135 kDefaultDeviceId); |
130 | 136 |
131 SyncWithAllThreads(); | 137 SyncWithAllThreads(); |
132 | 138 |
133 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 139 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
134 } | 140 } |
135 SyncWithAllThreads(); | 141 SyncWithAllThreads(); |
136 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 142 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
137 } | 143 } |
138 | 144 |
139 void PlayTest(base::Closure done) { | 145 void PlayTest(base::Closure done) { |
140 EXPECT_CALL(media_observer_, | 146 EXPECT_CALL(media_observer_, |
141 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 147 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
142 EXPECT_CALL(event_handler_, | 148 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
143 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
144 EXPECT_CALL(mirroring_manager_, | 149 EXPECT_CALL(mirroring_manager_, |
145 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 150 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
146 | 151 |
147 { | 152 { |
148 AudioOutputDelegateImpl delegate( | 153 AudioOutputDelegateImpl delegate( |
149 &event_handler_, audio_manager_.get(), | 154 &event_handler_, audio_manager_.get(), |
150 log_factory_.CreateAudioLog( | 155 log_factory_.CreateAudioLog( |
151 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 156 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
152 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 157 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
153 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 158 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
154 kDefaultDeviceId); | 159 kDefaultDeviceId); |
155 | 160 |
156 delegate.OnPlayStream(); | 161 delegate.OnPlayStream(); |
157 | 162 |
158 SyncWithAllThreads(); | 163 SyncWithAllThreads(); |
159 | 164 |
160 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 165 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
161 } | 166 } |
162 SyncWithAllThreads(); | 167 SyncWithAllThreads(); |
163 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 168 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
164 } | 169 } |
165 | 170 |
166 void PauseTest(base::Closure done) { | 171 void PauseTest(base::Closure done) { |
167 EXPECT_CALL(media_observer_, | 172 EXPECT_CALL(media_observer_, |
168 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 173 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
169 EXPECT_CALL(event_handler_, | 174 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
170 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
171 EXPECT_CALL(mirroring_manager_, | 175 EXPECT_CALL(mirroring_manager_, |
172 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 176 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
173 | 177 |
174 { | 178 { |
175 AudioOutputDelegateImpl delegate( | 179 AudioOutputDelegateImpl delegate( |
176 &event_handler_, audio_manager_.get(), | 180 &event_handler_, audio_manager_.get(), |
177 log_factory_.CreateAudioLog( | 181 log_factory_.CreateAudioLog( |
178 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 182 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
179 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 183 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
180 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 184 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
181 kDefaultDeviceId); | 185 kDefaultDeviceId); |
182 | 186 |
183 delegate.OnPauseStream(); | 187 delegate.OnPauseStream(); |
184 | 188 |
185 SyncWithAllThreads(); | 189 SyncWithAllThreads(); |
186 | 190 |
187 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 191 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
188 } | 192 } |
189 SyncWithAllThreads(); | 193 SyncWithAllThreads(); |
190 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 194 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
191 } | 195 } |
192 | 196 |
193 void PlayPausePlayTest(base::Closure done) { | 197 void PlayPausePlayTest(base::Closure done) { |
194 EXPECT_CALL(media_observer_, | 198 EXPECT_CALL(media_observer_, |
195 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 199 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
196 EXPECT_CALL(event_handler_, | 200 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
197 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
198 EXPECT_CALL(mirroring_manager_, | 201 EXPECT_CALL(mirroring_manager_, |
199 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 202 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
200 | 203 |
201 { | 204 { |
202 AudioOutputDelegateImpl delegate( | 205 AudioOutputDelegateImpl delegate( |
203 &event_handler_, audio_manager_.get(), | 206 &event_handler_, audio_manager_.get(), |
204 log_factory_.CreateAudioLog( | 207 log_factory_.CreateAudioLog( |
205 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 208 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
206 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 209 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
207 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 210 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
208 kDefaultDeviceId); | 211 kDefaultDeviceId); |
209 | 212 |
210 delegate.OnPlayStream(); | 213 delegate.OnPlayStream(); |
211 delegate.OnPauseStream(); | 214 delegate.OnPauseStream(); |
212 delegate.OnPlayStream(); | 215 delegate.OnPlayStream(); |
213 | 216 |
214 SyncWithAllThreads(); | 217 SyncWithAllThreads(); |
215 | 218 |
216 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 219 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
217 } | 220 } |
218 SyncWithAllThreads(); | 221 SyncWithAllThreads(); |
219 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 222 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
220 } | 223 } |
221 | 224 |
222 void PlayPlayTest(base::Closure done) { | 225 void PlayPlayTest(base::Closure done) { |
223 EXPECT_CALL(media_observer_, | 226 EXPECT_CALL(media_observer_, |
224 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 227 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
225 EXPECT_CALL(event_handler_, | 228 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
226 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
227 EXPECT_CALL(mirroring_manager_, | 229 EXPECT_CALL(mirroring_manager_, |
228 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 230 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
229 | 231 |
230 { | 232 { |
231 AudioOutputDelegateImpl delegate( | 233 AudioOutputDelegateImpl delegate( |
232 &event_handler_, audio_manager_.get(), | 234 &event_handler_, audio_manager_.get(), |
233 log_factory_.CreateAudioLog( | 235 log_factory_.CreateAudioLog( |
234 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 236 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
235 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 237 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
236 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 238 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
237 kDefaultDeviceId); | 239 kDefaultDeviceId); |
238 | 240 |
239 delegate.OnPlayStream(); | 241 delegate.OnPlayStream(); |
240 delegate.OnPlayStream(); | 242 delegate.OnPlayStream(); |
241 | 243 |
242 SyncWithAllThreads(); | 244 SyncWithAllThreads(); |
243 | 245 |
244 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 246 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
245 } | 247 } |
246 SyncWithAllThreads(); | 248 SyncWithAllThreads(); |
247 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 249 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
248 } | 250 } |
249 | 251 |
250 void CreateDivertTest(base::Closure done) { | 252 void CreateDivertTest(base::Closure done) { |
251 EXPECT_CALL(media_observer_, | 253 EXPECT_CALL(media_observer_, |
252 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 254 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
253 EXPECT_CALL(event_handler_, | 255 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
254 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
255 EXPECT_CALL(mirroring_manager_, | 256 EXPECT_CALL(mirroring_manager_, |
256 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 257 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
257 | 258 |
258 DummyAudioOutputStream stream; | 259 DummyAudioOutputStream stream; |
259 { | 260 { |
260 AudioOutputDelegateImpl delegate( | 261 AudioOutputDelegateImpl delegate( |
261 &event_handler_, audio_manager_.get(), | 262 &event_handler_, audio_manager_.get(), |
262 log_factory_.CreateAudioLog( | 263 log_factory_.CreateAudioLog( |
263 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 264 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
264 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 265 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
265 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 266 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
266 kDefaultDeviceId); | 267 kDefaultDeviceId); |
267 | 268 |
268 delegate.GetController()->StartDiverting(&stream); | 269 delegate.GetController()->StartDiverting(&stream); |
269 | 270 |
270 SyncWithAllThreads(); | 271 SyncWithAllThreads(); |
271 | 272 |
272 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 273 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
273 } | 274 } |
274 SyncWithAllThreads(); | 275 SyncWithAllThreads(); |
275 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 276 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
276 } | 277 } |
277 | 278 |
278 void CreateDivertPauseTest(base::Closure done) { | 279 void CreateDivertPauseTest(base::Closure done) { |
279 EXPECT_CALL(media_observer_, | 280 EXPECT_CALL(media_observer_, |
280 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 281 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
281 EXPECT_CALL(event_handler_, | 282 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
282 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
283 EXPECT_CALL(mirroring_manager_, | 283 EXPECT_CALL(mirroring_manager_, |
284 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 284 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
285 | 285 |
286 DummyAudioOutputStream stream; | 286 DummyAudioOutputStream stream; |
287 { | 287 { |
288 AudioOutputDelegateImpl delegate( | 288 AudioOutputDelegateImpl delegate( |
289 &event_handler_, audio_manager_.get(), | 289 &event_handler_, audio_manager_.get(), |
290 log_factory_.CreateAudioLog( | 290 log_factory_.CreateAudioLog( |
291 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 291 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
292 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 292 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
293 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 293 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
294 kDefaultDeviceId); | 294 kDefaultDeviceId); |
295 | 295 |
296 delegate.GetController()->StartDiverting(&stream); | 296 delegate.GetController()->StartDiverting(&stream); |
297 | 297 |
298 SyncWithAllThreads(); | 298 SyncWithAllThreads(); |
299 delegate.OnPauseStream(); | 299 delegate.OnPauseStream(); |
300 | 300 |
301 SyncWithAllThreads(); | 301 SyncWithAllThreads(); |
302 | 302 |
303 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 303 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
304 } | 304 } |
305 SyncWithAllThreads(); | 305 SyncWithAllThreads(); |
306 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 306 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
307 } | 307 } |
308 | 308 |
309 void PlayDivertTest(base::Closure done) { | 309 void PlayDivertTest(base::Closure done) { |
310 EXPECT_CALL(media_observer_, | 310 EXPECT_CALL(media_observer_, |
311 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 311 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
312 EXPECT_CALL(event_handler_, | 312 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
313 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
314 EXPECT_CALL(mirroring_manager_, | 313 EXPECT_CALL(mirroring_manager_, |
315 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 314 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
316 | 315 |
317 DummyAudioOutputStream stream; | 316 DummyAudioOutputStream stream; |
318 { | 317 { |
319 AudioOutputDelegateImpl delegate( | 318 AudioOutputDelegateImpl delegate( |
320 &event_handler_, audio_manager_.get(), | 319 &event_handler_, audio_manager_.get(), |
321 log_factory_.CreateAudioLog( | 320 log_factory_.CreateAudioLog( |
322 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 321 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
323 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 322 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
324 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 323 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
325 kDefaultDeviceId); | 324 kDefaultDeviceId); |
326 | 325 |
327 delegate.OnPlayStream(); | 326 delegate.OnPlayStream(); |
328 delegate.GetController()->StartDiverting(&stream); | 327 delegate.GetController()->StartDiverting(&stream); |
329 | 328 |
330 SyncWithAllThreads(); | 329 SyncWithAllThreads(); |
331 | 330 |
332 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 331 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
333 } | 332 } |
334 SyncWithAllThreads(); | 333 SyncWithAllThreads(); |
335 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 334 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
336 } | 335 } |
337 | 336 |
338 void ErrorTest(base::Closure done) { | 337 void ErrorTest(base::Closure done) { |
339 EXPECT_CALL(media_observer_, | 338 EXPECT_CALL(media_observer_, |
340 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 339 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
341 EXPECT_CALL(event_handler_, | 340 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
342 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
343 EXPECT_CALL(event_handler_, OnStreamError(kStreamId)); | 341 EXPECT_CALL(event_handler_, OnStreamError(kStreamId)); |
344 EXPECT_CALL(mirroring_manager_, | 342 EXPECT_CALL(mirroring_manager_, |
345 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 343 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
346 | 344 |
347 { | 345 { |
348 AudioOutputDelegateImpl delegate( | 346 AudioOutputDelegateImpl delegate( |
349 &event_handler_, audio_manager_.get(), | 347 &event_handler_, audio_manager_.get(), |
350 log_factory_.CreateAudioLog( | 348 log_factory_.CreateAudioLog( |
351 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 349 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
352 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 350 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
(...skipping 26 matching lines...) Expand all Loading... |
379 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 377 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
380 kDefaultDeviceId); | 378 kDefaultDeviceId); |
381 } | 379 } |
382 SyncWithAllThreads(); | 380 SyncWithAllThreads(); |
383 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 381 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
384 } | 382 } |
385 | 383 |
386 void PlayAndDestroyTest(base::Closure done) { | 384 void PlayAndDestroyTest(base::Closure done) { |
387 EXPECT_CALL(media_observer_, | 385 EXPECT_CALL(media_observer_, |
388 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 386 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
389 EXPECT_CALL(event_handler_, | 387 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
390 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
391 EXPECT_CALL(mirroring_manager_, | 388 EXPECT_CALL(mirroring_manager_, |
392 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 389 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
393 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 390 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
394 | 391 |
395 { | 392 { |
396 AudioOutputDelegateImpl delegate( | 393 AudioOutputDelegateImpl delegate( |
397 &event_handler_, audio_manager_.get(), | 394 &event_handler_, audio_manager_.get(), |
398 log_factory_.CreateAudioLog( | 395 log_factory_.CreateAudioLog( |
399 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 396 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
400 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 397 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
401 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), | 398 kRenderProcessId, media::AudioParameters::UnavailableDeviceParams(), |
402 kDefaultDeviceId); | 399 kDefaultDeviceId); |
403 | 400 |
404 SyncWithAllThreads(); | 401 SyncWithAllThreads(); |
405 | 402 |
406 delegate.OnPlayStream(); | 403 delegate.OnPlayStream(); |
407 } | 404 } |
408 SyncWithAllThreads(); | 405 SyncWithAllThreads(); |
409 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 406 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
410 } | 407 } |
411 | 408 |
412 void ErrorAndDestroyTest(base::Closure done) { | 409 void ErrorAndDestroyTest(base::Closure done) { |
413 EXPECT_CALL(media_observer_, | 410 EXPECT_CALL(media_observer_, |
414 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | 411 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); |
415 EXPECT_CALL(event_handler_, | 412 EXPECT_CALL(event_handler_, GotOnStreamCreated()); |
416 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
417 EXPECT_CALL(mirroring_manager_, | 413 EXPECT_CALL(mirroring_manager_, |
418 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | 414 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); |
419 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | 415 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); |
420 | 416 |
421 { | 417 { |
422 AudioOutputDelegateImpl delegate( | 418 AudioOutputDelegateImpl delegate( |
423 &event_handler_, audio_manager_.get(), | 419 &event_handler_, audio_manager_.get(), |
424 log_factory_.CreateAudioLog( | 420 log_factory_.CreateAudioLog( |
425 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | 421 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), |
426 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | 422 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
558 TEST_F(AudioOutputDelegateTest, ErrorAndDestroy) { | 554 TEST_F(AudioOutputDelegateTest, ErrorAndDestroy) { |
559 base::RunLoop l; | 555 base::RunLoop l; |
560 BrowserThread::PostTask( | 556 BrowserThread::PostTask( |
561 BrowserThread::IO, FROM_HERE, | 557 BrowserThread::IO, FROM_HERE, |
562 base::Bind(&AudioOutputDelegateTest::PlayAndDestroyTest, | 558 base::Bind(&AudioOutputDelegateTest::PlayAndDestroyTest, |
563 base::Unretained(this), l.QuitClosure())); | 559 base::Unretained(this), l.QuitClosure())); |
564 l.Run(); | 560 l.Run(); |
565 } | 561 } |
566 | 562 |
567 } // namespace content | 563 } // namespace content |
OLD | NEW |