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