1// Copyright (c) 2013 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/browser/media/capture/audio_mirroring_manager.h"
6
7#include <map>
8#include <utility>
9
10#include "base/bind.h"
11#include "base/bind_helpers.h"
12#include "base/message_loop/message_loop.h"
13#include "base/synchronization/waitable_event.h"
14#include "content/browser/browser_thread_impl.h"
15#include "media/audio/audio_parameters.h"
16#include "testing/gmock/include/gmock/gmock.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19using media::AudioOutputStream;
20using media::AudioParameters;
21using testing::_;
22using testing::Invoke;
23using testing::NotNull;
24using testing::Ref;
25using testing::Return;
26using testing::ReturnRef;
27
28namespace content {
29
30namespace {
31
32class MockDiverter : public AudioMirroringManager::Diverter {
33 public:
34  MOCK_METHOD0(GetAudioParameters, const AudioParameters&());
35  MOCK_METHOD1(StartDiverting, void(AudioOutputStream*));
36  MOCK_METHOD0(StopDiverting, void());
37};
38
39class MockMirroringDestination
40    : public AudioMirroringManager::MirroringDestination {
41 public:
42  typedef AudioMirroringManager::SourceFrameRef SourceFrameRef;
43
44  MockMirroringDestination(int render_process_id, int render_frame_id)
45      : render_process_id_(render_process_id),
46        render_frame_id_(render_frame_id),
47        query_count_(0) {}
48
49  MOCK_METHOD2(QueryForMatches,
50               void(const std::set<SourceFrameRef>& candidates,
51                    const MatchesCallback& results_callback));
52  MOCK_METHOD1(AddInput,
53               media::AudioOutputStream*(const media::AudioParameters& params));
54
55  void SimulateQuery(const std::set<SourceFrameRef>& candidates,
56                     const MatchesCallback& results_callback) {
57    ++query_count_;
58
59    std::set<SourceFrameRef> result;
60    if (candidates.find(SourceFrameRef(render_process_id_, render_frame_id_)) !=
61            candidates.end()) {
62      result.insert(SourceFrameRef(render_process_id_, render_frame_id_));
63    }
64    results_callback.Run(result);
65  }
66
67  media::AudioOutputStream* SimulateAddInput(
68      const media::AudioParameters& params) {
69    static AudioOutputStream* const kNonNullPointer =
70        reinterpret_cast<AudioOutputStream*>(0x11111110);
71    return kNonNullPointer;
72  }
73
74  int query_count() const {
75    return query_count_;
76  }
77
78 private:
79  const int render_process_id_;
80  const int render_frame_id_;
81  int query_count_;
82};
83
84}  // namespace
85
86class AudioMirroringManagerTest : public testing::Test {
87 public:
88  typedef AudioMirroringManager::Diverter Diverter;
89  typedef AudioMirroringManager::MirroringDestination MirroringDestination;
90  typedef AudioMirroringManager::StreamRoutes StreamRoutes;
91
92  AudioMirroringManagerTest()
93      : io_thread_(BrowserThread::IO, &message_loop_),
94        params_(AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
95                AudioParameters::kAudioCDSampleRate, 16,
96                AudioParameters::kAudioCDSampleRate / 10) {}
97
98  MockDiverter* CreateStream(
99      int render_process_id, int render_frame_id, int expected_times_diverted) {
100    MockDiverter* const diverter = new MockDiverter();
101    if (expected_times_diverted > 0) {
102      EXPECT_CALL(*diverter, GetAudioParameters())
103          .Times(expected_times_diverted)
104          .WillRepeatedly(ReturnRef(params_));
105      EXPECT_CALL(*diverter, StartDiverting(NotNull()))
106          .Times(expected_times_diverted);
107      EXPECT_CALL(*diverter, StopDiverting())
108          .Times(expected_times_diverted);
109    }
110
111    mirroring_manager_.AddDiverter(
112        render_process_id, render_frame_id, diverter);
113
114    return diverter;
115  }
116
117  void KillStream(MockDiverter* diverter) {
118    mirroring_manager_.RemoveDiverter(diverter);
119    delete diverter;
120  }
121
122  void StartMirroringTo(const scoped_ptr<MockMirroringDestination>& dest,
123                        int expected_inputs_added) {
124    EXPECT_CALL(*dest, QueryForMatches(_, _))
125        .WillRepeatedly(Invoke(dest.get(),
126                               &MockMirroringDestination::SimulateQuery));
127    if (expected_inputs_added > 0) {
128      EXPECT_CALL(*dest, AddInput(Ref(params_)))
129          .Times(expected_inputs_added)
130          .WillRepeatedly(Invoke(dest.get(),
131                                 &MockMirroringDestination::SimulateAddInput))
132          .RetiresOnSaturation();
133    }
134
135    mirroring_manager_.StartMirroring(dest.get());
136  }
137
138  void StopMirroringTo(const scoped_ptr<MockMirroringDestination>& dest) {
139    mirroring_manager_.StopMirroring(dest.get());
140  }
141
142  int CountStreamsDivertedTo(
143      const scoped_ptr<MockMirroringDestination>& dest) const {
144    int count = 0;
145    for (StreamRoutes::const_iterator it = mirroring_manager_.routes_.begin();
146         it != mirroring_manager_.routes_.end(); ++it) {
147      if (it->destination == dest.get())
148        ++count;
149    }
150    return count;
151  }
152
153  void ExpectNoLongerManagingAnything() const {
154    EXPECT_TRUE(mirroring_manager_.routes_.empty());
155    EXPECT_TRUE(mirroring_manager_.sessions_.empty());
156  }
157
158 private:
159  base::MessageLoopForIO message_loop_;
160  BrowserThreadImpl io_thread_;
161  AudioParameters params_;
162  AudioMirroringManager mirroring_manager_;
163
164  DISALLOW_COPY_AND_ASSIGN(AudioMirroringManagerTest);
165};
166
167namespace {
168const int kRenderProcessId = 123;
169const int kRenderFrameId = 456;
170const int kAnotherRenderProcessId = 789;
171const int kAnotherRenderFrameId = 1234;
172const int kYetAnotherRenderProcessId = 4560;
173const int kYetAnotherRenderFrameId = 7890;
174}
175
176TEST_F(AudioMirroringManagerTest, MirroringSessionOfNothing) {
177  const scoped_ptr<MockMirroringDestination> destination(
178      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
179  StartMirroringTo(destination, 0);
180  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
181
182  StopMirroringTo(destination);
183  EXPECT_EQ(0, destination->query_count());
184
185  ExpectNoLongerManagingAnything();
186}
187
188TEST_F(AudioMirroringManagerTest, TwoMirroringSessionsOfNothing) {
189  const scoped_ptr<MockMirroringDestination> destination(
190      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
191  StartMirroringTo(destination, 0);
192  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
193
194  StopMirroringTo(destination);
195  EXPECT_EQ(0, destination->query_count());
196
197  const scoped_ptr<MockMirroringDestination> another_destination(
198      new MockMirroringDestination(kAnotherRenderProcessId,
199                                   kAnotherRenderFrameId));
200  StartMirroringTo(another_destination, 0);
201  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
202
203  StopMirroringTo(another_destination);
204  EXPECT_EQ(0, another_destination->query_count());
205
206  ExpectNoLongerManagingAnything();
207}
208
209// Tests that a mirroring session starts after, and ends before, a stream that
210// will be diverted to it.
211TEST_F(AudioMirroringManagerTest, StreamLifetimeAroundMirroringSession) {
212  MockDiverter* const stream =
213      CreateStream(kRenderProcessId, kRenderFrameId, 1);
214  const scoped_ptr<MockMirroringDestination> destination(
215      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
216  StartMirroringTo(destination, 1);
217  EXPECT_EQ(1, destination->query_count());
218  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
219
220  StopMirroringTo(destination);
221  EXPECT_EQ(1, destination->query_count());
222  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
223
224  KillStream(stream);
225  EXPECT_EQ(1, destination->query_count());
226  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
227
228  ExpectNoLongerManagingAnything();
229}
230
231// Tests that a mirroring session starts before, and ends after, a stream that
232// will be diverted to it.
233TEST_F(AudioMirroringManagerTest, StreamLifetimeWithinMirroringSession) {
234  const scoped_ptr<MockMirroringDestination> destination(
235      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
236  StartMirroringTo(destination, 1);
237  EXPECT_EQ(0, destination->query_count());
238  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
239
240  MockDiverter* const stream =
241      CreateStream(kRenderProcessId, kRenderFrameId, 1);
242  EXPECT_EQ(1, destination->query_count());
243  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
244
245  KillStream(stream);
246  EXPECT_EQ(1, destination->query_count());
247  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
248
249  StopMirroringTo(destination);
250  EXPECT_EQ(1, destination->query_count());
251  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
252
253  ExpectNoLongerManagingAnything();
254}
255
256// Tests that a stream is diverted correctly as two mirroring sessions come and
257// go.
258TEST_F(AudioMirroringManagerTest, StreamLifetimeAcrossTwoMirroringSessions) {
259  MockDiverter* const stream =
260      CreateStream(kRenderProcessId, kRenderFrameId, 2);
261
262  const scoped_ptr<MockMirroringDestination> destination(
263      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
264  StartMirroringTo(destination, 1);
265  EXPECT_EQ(1, destination->query_count());
266  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
267
268  StopMirroringTo(destination);
269  EXPECT_EQ(1, destination->query_count());
270  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
271
272  const scoped_ptr<MockMirroringDestination> second_destination(
273      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
274  StartMirroringTo(second_destination, 1);
275  EXPECT_EQ(1, destination->query_count());
276  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
277  EXPECT_EQ(1, second_destination->query_count());
278  EXPECT_EQ(1, CountStreamsDivertedTo(second_destination));
279
280  StopMirroringTo(second_destination);
281  EXPECT_EQ(1, destination->query_count());
282  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
283  EXPECT_EQ(1, second_destination->query_count());
284  EXPECT_EQ(0, CountStreamsDivertedTo(second_destination));
285
286  KillStream(stream);
287  EXPECT_EQ(1, destination->query_count());
288  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
289  EXPECT_EQ(1, second_destination->query_count());
290  EXPECT_EQ(0, CountStreamsDivertedTo(second_destination));
291
292  ExpectNoLongerManagingAnything();
293}
294
295// Tests that a stream does not flip-flop between two destinations that are a
296// match for it.
297TEST_F(AudioMirroringManagerTest, StreamDivertingStickyToOneDestination_1) {
298  MockDiverter* const stream =
299      CreateStream(kRenderProcessId, kRenderFrameId, 2);
300
301  const scoped_ptr<MockMirroringDestination> destination(
302      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
303  StartMirroringTo(destination, 1);
304  EXPECT_EQ(1, destination->query_count());
305  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
306
307  const scoped_ptr<MockMirroringDestination> replacement_destination(
308      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
309  StartMirroringTo(replacement_destination, 1);
310  EXPECT_EQ(1, destination->query_count());
311  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
312  EXPECT_EQ(0, replacement_destination->query_count());
313  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
314
315  StopMirroringTo(destination);
316  EXPECT_EQ(1, destination->query_count());
317  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
318  EXPECT_EQ(1, replacement_destination->query_count());
319  EXPECT_EQ(1, CountStreamsDivertedTo(replacement_destination));
320
321  StopMirroringTo(replacement_destination);
322  EXPECT_EQ(1, destination->query_count());
323  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
324  EXPECT_EQ(1, replacement_destination->query_count());
325  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
326
327  KillStream(stream);
328  EXPECT_EQ(1, destination->query_count());
329  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
330  EXPECT_EQ(1, replacement_destination->query_count());
331  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
332
333  ExpectNoLongerManagingAnything();
334}
335
336// Same as StreamDivertingStickyToOneDestination_1, with a different order of
337// operations that should have the same effects.
338TEST_F(AudioMirroringManagerTest, StreamDivertingStickyToOneDestination_2) {
339  MockDiverter* const stream =
340      CreateStream(kRenderProcessId, kRenderFrameId, 2);
341
342  const scoped_ptr<MockMirroringDestination> destination(
343      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
344  StartMirroringTo(destination, 1);
345  EXPECT_EQ(1, destination->query_count());
346  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
347
348  const scoped_ptr<MockMirroringDestination> replacement_destination(
349      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
350  StartMirroringTo(replacement_destination, 1);
351  EXPECT_EQ(1, destination->query_count());
352  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
353  EXPECT_EQ(0, replacement_destination->query_count());
354  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
355
356  StopMirroringTo(destination);
357  EXPECT_EQ(1, destination->query_count());
358  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
359  EXPECT_EQ(1, replacement_destination->query_count());
360  EXPECT_EQ(1, CountStreamsDivertedTo(replacement_destination));
361
362  KillStream(stream);
363  EXPECT_EQ(1, destination->query_count());
364  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
365  EXPECT_EQ(1, replacement_destination->query_count());
366  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
367
368  StopMirroringTo(replacement_destination);
369  EXPECT_EQ(1, destination->query_count());
370  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
371  EXPECT_EQ(1, replacement_destination->query_count());
372  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
373
374  ExpectNoLongerManagingAnything();
375}
376
377// Same as StreamDivertingStickyToOneDestination_1, except that the stream is
378// killed before the first destination is stopped.  Therefore, the second
379// destination should never see the stream.
380TEST_F(AudioMirroringManagerTest, StreamDivertingStickyToOneDestination_3) {
381  MockDiverter* const stream =
382      CreateStream(kRenderProcessId, kRenderFrameId, 1);
383
384  const scoped_ptr<MockMirroringDestination> destination(
385      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
386  StartMirroringTo(destination, 1);
387  EXPECT_EQ(1, destination->query_count());
388  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
389
390  const scoped_ptr<MockMirroringDestination> replacement_destination(
391      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
392  StartMirroringTo(replacement_destination, 0);
393  EXPECT_EQ(1, destination->query_count());
394  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
395  EXPECT_EQ(0, replacement_destination->query_count());
396  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
397
398  KillStream(stream);
399  EXPECT_EQ(1, destination->query_count());
400  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
401  EXPECT_EQ(0, replacement_destination->query_count());
402  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
403
404  StopMirroringTo(destination);
405  EXPECT_EQ(1, destination->query_count());
406  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
407  EXPECT_EQ(0, replacement_destination->query_count());
408  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
409
410  StopMirroringTo(replacement_destination);
411  EXPECT_EQ(1, destination->query_count());
412  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
413  EXPECT_EQ(0, replacement_destination->query_count());
414  EXPECT_EQ(0, CountStreamsDivertedTo(replacement_destination));
415
416  ExpectNoLongerManagingAnything();
417}
418
419// Tests that multiple streams are diverted/mixed to one destination.
420TEST_F(AudioMirroringManagerTest, MultipleStreamsInOneMirroringSession) {
421  MockDiverter* const stream1 =
422      CreateStream(kRenderProcessId, kRenderFrameId, 1);
423
424  const scoped_ptr<MockMirroringDestination> destination(
425      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
426  StartMirroringTo(destination, 3);
427  EXPECT_EQ(1, destination->query_count());
428  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
429
430  MockDiverter* const stream2 =
431      CreateStream(kRenderProcessId, kRenderFrameId, 1);
432  EXPECT_EQ(2, destination->query_count());
433  EXPECT_EQ(2, CountStreamsDivertedTo(destination));
434
435  MockDiverter* const stream3 =
436      CreateStream(kRenderProcessId, kRenderFrameId, 1);
437  EXPECT_EQ(3, destination->query_count());
438  EXPECT_EQ(3, CountStreamsDivertedTo(destination));
439
440  KillStream(stream2);
441  EXPECT_EQ(3, destination->query_count());
442  EXPECT_EQ(2, CountStreamsDivertedTo(destination));
443
444  StopMirroringTo(destination);
445  EXPECT_EQ(3, destination->query_count());
446  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
447
448  KillStream(stream3);
449  EXPECT_EQ(3, destination->query_count());
450  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
451
452  KillStream(stream1);
453  EXPECT_EQ(3, destination->query_count());
454  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
455
456  ExpectNoLongerManagingAnything();
457}
458
459// A random interleaving of operations for three separate targets, each of which
460// has one stream mirrored to one destination.
461TEST_F(AudioMirroringManagerTest, ThreeSeparateMirroringSessions) {
462  MockDiverter* const stream =
463      CreateStream(kRenderProcessId, kRenderFrameId, 1);
464
465  const scoped_ptr<MockMirroringDestination> destination(
466      new MockMirroringDestination(kRenderProcessId, kRenderFrameId));
467  StartMirroringTo(destination, 1);
468  EXPECT_EQ(1, destination->query_count());
469  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
470
471  const scoped_ptr<MockMirroringDestination> another_destination(
472      new MockMirroringDestination(kAnotherRenderProcessId,
473                                   kAnotherRenderFrameId));
474  StartMirroringTo(another_destination, 1);
475  EXPECT_EQ(1, destination->query_count());
476  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
477  EXPECT_EQ(0, another_destination->query_count());
478  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
479
480  MockDiverter* const another_stream =
481      CreateStream(kAnotherRenderProcessId, kAnotherRenderFrameId, 1);
482  EXPECT_EQ(2, destination->query_count());
483  EXPECT_EQ(1, CountStreamsDivertedTo(destination));
484  EXPECT_EQ(1, another_destination->query_count());
485  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));
486
487  KillStream(stream);
488  EXPECT_EQ(2, destination->query_count());
489  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
490  EXPECT_EQ(1, another_destination->query_count());
491  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));
492
493  MockDiverter* const yet_another_stream =
494      CreateStream(kYetAnotherRenderProcessId, kYetAnotherRenderFrameId, 1);
495  EXPECT_EQ(3, destination->query_count());
496  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
497  EXPECT_EQ(2, another_destination->query_count());
498  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));
499
500  const scoped_ptr<MockMirroringDestination> yet_another_destination(
501      new MockMirroringDestination(kYetAnotherRenderProcessId,
502                                   kYetAnotherRenderFrameId));
503  StartMirroringTo(yet_another_destination, 1);
504  EXPECT_EQ(3, destination->query_count());
505  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
506  EXPECT_EQ(2, another_destination->query_count());
507  EXPECT_EQ(1, CountStreamsDivertedTo(another_destination));
508  EXPECT_EQ(1, yet_another_destination->query_count());
509  EXPECT_EQ(1, CountStreamsDivertedTo(yet_another_destination));
510
511  StopMirroringTo(another_destination);
512  EXPECT_EQ(4, destination->query_count());
513  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
514  EXPECT_EQ(2, another_destination->query_count());
515  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
516  EXPECT_EQ(2, yet_another_destination->query_count());
517  EXPECT_EQ(1, CountStreamsDivertedTo(yet_another_destination));
518
519  StopMirroringTo(yet_another_destination);
520  EXPECT_EQ(5, destination->query_count());
521  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
522  EXPECT_EQ(2, another_destination->query_count());
523  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
524  EXPECT_EQ(2, yet_another_destination->query_count());
525  EXPECT_EQ(0, CountStreamsDivertedTo(yet_another_destination));
526
527  StopMirroringTo(destination);
528  EXPECT_EQ(5, destination->query_count());
529  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
530  EXPECT_EQ(2, another_destination->query_count());
531  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
532  EXPECT_EQ(2, yet_another_destination->query_count());
533  EXPECT_EQ(0, CountStreamsDivertedTo(yet_another_destination));
534
535  KillStream(another_stream);
536  EXPECT_EQ(5, destination->query_count());
537  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
538  EXPECT_EQ(2, another_destination->query_count());
539  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
540  EXPECT_EQ(2, yet_another_destination->query_count());
541  EXPECT_EQ(0, CountStreamsDivertedTo(yet_another_destination));
542
543  KillStream(yet_another_stream);
544  EXPECT_EQ(5, destination->query_count());
545  EXPECT_EQ(0, CountStreamsDivertedTo(destination));
546  EXPECT_EQ(2, another_destination->query_count());
547  EXPECT_EQ(0, CountStreamsDivertedTo(another_destination));
548  EXPECT_EQ(2, yet_another_destination->query_count());
549  EXPECT_EQ(0, CountStreamsDivertedTo(yet_another_destination));
550
551  ExpectNoLongerManagingAnything();
552}
553
554}  // namespace content
555