AudioDeviceTest.StartPlayoutOnTwoInstances now verifies two active playing streams

webrtc/modules/audio_device/ios/audio_device_unittest_ios.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 410 matching lines @@
                                       const bool keyPressed,
                                       uint32_t& newMicLevel) {
     EXPECT_TRUE(rec_mode()) << "No test is expecting these callbacks.";
     rec_count_++;
     // Process the recorded audio stream if an AudioStreamInterface
     // implementation exists.
     if (audio_stream_) {
       audio_stream_->Write(audioSamples, nSamples);
     }
     if (ReceivedEnoughCallbacks()) {
-      test_is_done_->Set();
+      if (test_is_done_) {
+        test_is_done_->Set();
+      }
     }
     return 0;
   }
 
   int32_t RealNeedMorePlayData(const size_t nSamples,
                                const size_t nBytesPerSample,
                                const uint8_t nChannels,
                                const uint32_t samplesPerSec,
                                void* audioSamples,
                                size_t& nSamplesOut,
                                int64_t* elapsed_time_ms,
                                int64_t* ntp_time_ms) {
     EXPECT_TRUE(play_mode()) << "No test is expecting these callbacks.";
     play_count_++;
     nSamplesOut = nSamples;
     // Read (possibly processed) audio stream samples to be played out if an
     // AudioStreamInterface implementation exists.
     if (audio_stream_) {
       audio_stream_->Read(audioSamples, nSamples);
     }
     if (ReceivedEnoughCallbacks()) {
-      test_is_done_->Set();
+      if (test_is_done_) {
+        test_is_done_->Set();
+      }
     }
     return 0;
   }
 
   bool ReceivedEnoughCallbacks() {
     bool recording_done = false;
     if (rec_mode())
       recording_done = rec_count_ >= num_callbacks_;
     else
       recording_done = true;
@@ skipping 167 matching lines @@
 // RTC_DCHECK.
 TEST_F(AudioDeviceTest, StopPlayoutRequiresInitToRestart) {
   EXPECT_EQ(0, audio_device()->InitPlayout());
   EXPECT_EQ(0, audio_device()->StartPlayout());
   EXPECT_EQ(0, audio_device()->StopPlayout());
   EXPECT_FALSE(audio_device()->PlayoutIsInitialized());
 }
 
 // Verify that we can create two ADMs and start playing on the second ADM.
 // Only the first active instance shall activate an audio session and the
-// last active instace shall deactivate the audio session.
+// last active instance shall deactivate the audio session. The test does not
+// explicitly verify correct audio session calls but instead focuses on
+// ensuring that audio starts for both ADMs.
 TEST_F(AudioDeviceTest, StartPlayoutOnTwoInstances) {
   // Create and initialize a second/extra ADM instance. The default ADM is
   // created by the test harness.
   rtc::scoped_refptr<AudioDeviceModule> second_audio_device =
       CreateAudioDevice(AudioDeviceModule::kPlatformDefaultAudio);
   EXPECT_NE(second_audio_device.get(), nullptr);
   EXPECT_EQ(0, second_audio_device->Init());
 
-  // Start playout for the default ADM. Ignore the callback sequence.
+  // Start playout for the default ADM but don't wait here. Instead use the
+  // upcoming second stream for that. We set the same expectation on number
+  // of callbacks as for the second stream.
   NiceMock<MockAudioTransport> mock(kPlayout);
+  mock.HandleCallbacks(nullptr, nullptr, 0);
+  EXPECT_CALL(
+      mock, NeedMorePlayData(playout_frames_per_10ms_buffer(), kBytesPerSample,
+                             playout_channels(), playout_sample_rate(),
+                             NotNull(), _, _, _))
+      .Times(AtLeast(kNumCallbacks));
   EXPECT_EQ(0, audio_device()->RegisterAudioCallback(&mock));
   StartPlayout();
 
   // Initialize playout for the second ADM. If all is OK, the second ADM shall
   // reuse the audio session activated when the first ADM started playing.
   // This call will also ensure that we avoid a problem related to initializing
   // two different audio unit instances back to back (see webrtc:5166 for
   // details).
   EXPECT_EQ(0, second_audio_device->InitPlayout());
   EXPECT_TRUE(second_audio_device->PlayoutIsInitialized());
 
-  // Stop playout for the default ADM. The audio session shall not be
-  // deactivated since it is used by the second ADM.
-  StopPlayout();
-
   // Start playout for the second ADM and verify that it starts as intended.
   // Passing this test ensures that initialization of the second audio unit
-  // has been done successfully.
+  // has been done successfully and that there is no conflict with the already
+  // playing first ADM.
   MockAudioTransport mock2(kPlayout);
   mock2.HandleCallbacks(test_is_done_.get(), nullptr, kNumCallbacks);
   EXPECT_CALL(
       mock2, NeedMorePlayData(playout_frames_per_10ms_buffer(), kBytesPerSample,
                               playout_channels(), playout_sample_rate(),
                               NotNull(), _, _, _))
       .Times(AtLeast(kNumCallbacks));
   EXPECT_EQ(0, second_audio_device->RegisterAudioCallback(&mock2));
   EXPECT_EQ(0, second_audio_device->StartPlayout());
   EXPECT_TRUE(second_audio_device->Playing());
@@ skipping 147 matching lines @@
   StopPlayout();
   StopRecording();
   // Verify that the correct number of transmitted impulses are detected.
   EXPECT_EQ(latency_audio_stream->num_latency_values(),
             static_cast<size_t>(
                 kImpulseFrequencyInHz * kMeasureLatencyTimeInSec - 1));
   latency_audio_stream->PrintResults();
 }
 
 }  // namespace webrtc