Makes AudioOutputProxy -> AudioOutputDispatcher reference weak.

media/audio/audio_output_proxy_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
@@ skipping 193 matching lines @@
 
   // Basic Open() and Close() test.
   void OpenAndClose(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
 
-    AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy->Open());
     CloseAndWaitForCloseTimer(proxy, &stream);
   }
 
   // Creates a stream, and then calls Start() and Stop().
   void StartAndStop(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
     EXPECT_CALL(stream, SetVolume(_))
         .Times(1);
 
-    AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy->Open());
 
     proxy->Start(&callback_);
     OnStart();
     proxy->Stop();
 
     CloseAndWaitForCloseTimer(proxy, &stream);
     EXPECT_TRUE(stream.stop_called());
     EXPECT_TRUE(stream.start_called());
   }
 
   // Verify that the stream is closed after Stop() is called.
   void CloseAfterStop(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
     EXPECT_CALL(stream, SetVolume(_))
         .Times(1);
 
-    AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy->Open());
 
     proxy->Start(&callback_);
     OnStart();
     proxy->Stop();
 
     // Wait for the close timer to fire after StopStream().
     WaitForCloseTimer(&stream);
     proxy->Close();
     EXPECT_TRUE(stream.stop_called());
     EXPECT_TRUE(stream.start_called());
   }
 
   // Create two streams, but don't start them.  Only one device must be opened.
   void TwoStreams(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
 
-    AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);
-    AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy1 = dispatcher->CreateStreamProxy();
+    AudioOutputProxy* proxy2 = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy1->Open());
     EXPECT_TRUE(proxy2->Open());
     proxy1->Close();
     CloseAndWaitForCloseTimer(proxy2, &stream);
     EXPECT_FALSE(stream.stop_called());
     EXPECT_FALSE(stream.start_called());
   }
 
   // Open() method failed.
   void OpenFailed(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(false));
     EXPECT_CALL(stream, Close())
         .Times(1);
 
-    AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
     EXPECT_FALSE(proxy->Open());
     proxy->Close();
     EXPECT_FALSE(stream.stop_called());
     EXPECT_FALSE(stream.start_called());
   }
 
   void CreateAndWait(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
 
-    AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy->Open());
 
     WaitForCloseTimer(&stream);
     proxy->Close();
     EXPECT_FALSE(stream.stop_called());
     EXPECT_FALSE(stream.start_called());
   }
 
   void OneStream_TwoPlays(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
 
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
     EXPECT_CALL(stream, SetVolume(_))
         .Times(2);
 
-    AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy1 = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy1->Open());
 
     proxy1->Start(&callback_);
     OnStart();
     proxy1->Stop();
 
     // The stream should now be idle and get reused by |proxy2|.
-    AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy2 = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy2->Open());
     proxy2->Start(&callback_);
     OnStart();
     proxy2->Stop();
 
     proxy1->Close();
     CloseAndWaitForCloseTimer(proxy2, &stream);
     EXPECT_TRUE(stream.stop_called());
     EXPECT_TRUE(stream.start_called());
   }
 
   void TwoStreams_BothPlaying(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream1(&manager_, params_);
     MockAudioOutputStream stream2(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream1))
         .WillOnce(Return(&stream2));
 
     EXPECT_CALL(stream1, Open())
         .WillOnce(Return(true));
     EXPECT_CALL(stream1, SetVolume(_))
         .Times(1);
 
     EXPECT_CALL(stream2, Open())
         .WillOnce(Return(true));
     EXPECT_CALL(stream2, SetVolume(_))
         .Times(1);
 
-    AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);
-    AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy1 = dispatcher->CreateStreamProxy();
+    AudioOutputProxy* proxy2 = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy1->Open());
     EXPECT_TRUE(proxy2->Open());
 
     proxy1->Start(&callback_);
     proxy2->Start(&callback_);
     OnStart();
     proxy1->Stop();
     CloseAndWaitForCloseTimer(proxy1, &stream1);
 
     proxy2->Stop();
     CloseAndWaitForCloseTimer(proxy2, &stream2);
 
     EXPECT_TRUE(stream1.stop_called());
     EXPECT_TRUE(stream1.start_called());
     EXPECT_TRUE(stream2.stop_called());
     EXPECT_TRUE(stream2.start_called());
   }
 
   void StartFailed(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
 
-    AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
     EXPECT_TRUE(proxy->Open());
 
     WaitForCloseTimer(&stream);
 
     // |stream| is closed at this point. Start() should reopen it again.
     EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
         .Times(2)
         .WillRepeatedly(Return(reinterpret_cast<AudioOutputStream*>(NULL)));
 
     EXPECT_CALL(callback_, OnError(_))
         .Times(2);
 
     proxy->Start(&callback_);
 
     // Double Start() in the error case should be allowed since it's possible a
     // callback may not have had time to process the OnError() in between.
     proxy->Stop();
     proxy->Start(&callback_);
 
     Mock::VerifyAndClear(&callback_);
 
     proxy->Close();
   }
 
+  void DispatcherDestroyed_BeforeOpen(
+      std::unique_ptr<AudioOutputDispatcher> dispatcher) {
+    EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _)).Times(0);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
+    dispatcher.reset();
+    EXPECT_FALSE(proxy->Open());
+    proxy->Close();
+  }
+
+  void DispatcherDestroyed_BeforeStart(
+      std::unique_ptr<AudioOutputDispatcher> dispatcher) {
+    MockAudioOutputStream stream(&manager_, params_);
+    EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
+        .WillOnce(Return(&stream));
+    EXPECT_CALL(stream, Open()).WillOnce(Return(true));
+    EXPECT_CALL(stream, Close()).Times(1);
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
+    EXPECT_TRUE(proxy->Open());
+
+    EXPECT_CALL(callback_, OnError(_)).Times(1);
+    dispatcher.reset();
+    proxy->Start(&callback_);
+    proxy->Stop();
+    proxy->Close();
+  }
+
+  void DispatcherDestroyed_BeforeStop(
+      std::unique_ptr<AudioOutputDispatcher> dispatcher) {
+    MockAudioOutputStream stream(&manager_, params_);
+    EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
+        .WillOnce(Return(&stream));
+    EXPECT_CALL(stream, Open()).WillOnce(Return(true));
+    EXPECT_CALL(stream, Close()).Times(1);
+    EXPECT_CALL(stream, SetVolume(_)).Times(1);
+
+    AudioOutputProxy* proxy = dispatcher->CreateStreamProxy();
+    EXPECT_TRUE(proxy->Open());
+    proxy->Start(&callback_);
+    dispatcher.reset();
+    proxy->Stop();
+    proxy->Close();
+  }
+
   base::MessageLoop message_loop_;
   std::unique_ptr<AudioOutputDispatcherImpl> dispatcher_impl_;
   MockAudioManager manager_;
   MockAudioSourceCallback callback_;
   AudioParameters params_;
 };
 
 class AudioOutputResamplerTest : public AudioOutputProxyTest {
  public:
   void TearDown() override { AudioOutputProxyTest::TearDown(); }
@@ skipping 17 matching lines @@
         base::TimeDelta::FromMilliseconds(kStartRunTimeMs));
     run_loop.Run();
   }
 
  protected:
   AudioParameters resampler_params_;
   std::unique_ptr<AudioOutputResampler> resampler_;
 };
 
 TEST_F(AudioOutputProxyTest, CreateAndClose) {
-  AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_.get());
+  AudioOutputProxy* proxy = dispatcher_impl_->CreateStreamProxy();
   proxy->Close();
 }
 
 TEST_F(AudioOutputResamplerTest, CreateAndClose) {
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy = resampler_->CreateStreamProxy();
   proxy->Close();
 }
 
 TEST_F(AudioOutputProxyTest, OpenAndClose) {
   OpenAndClose(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, OpenAndClose) {
   OpenAndClose(resampler_.get());
 }
@@ skipping 59 matching lines @@
 
 // Start() method failed.
 TEST_F(AudioOutputProxyTest, StartFailed) {
   StartFailed(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, StartFailed) {
   StartFailed(resampler_.get());
 }
 
+TEST_F(AudioOutputProxyTest, DispatcherDestroyed_BeforeOpen) {
+  DispatcherDestroyed_BeforeOpen(std::move(dispatcher_impl_));
+}
+
+TEST_F(AudioOutputResamplerTest, DispatcherDestroyed_BeforeOpen) {
+  DispatcherDestroyed_BeforeOpen(std::move(resampler_));
+}
+
+TEST_F(AudioOutputProxyTest, DispatcherDestroyed_BeforeStart) {
+  DispatcherDestroyed_BeforeStart(std::move(dispatcher_impl_));
+}
+
+TEST_F(AudioOutputResamplerTest, DispatcherDestroyed_BeforeStart) {
+  DispatcherDestroyed_BeforeStart(std::move(resampler_));
+}
+
+TEST_F(AudioOutputProxyTest, DispatcherDestroyed_BeforeStop) {
+  DispatcherDestroyed_BeforeStop(std::move(dispatcher_impl_));
+}
+
+TEST_F(AudioOutputResamplerTest, DispatcherDestroyed_BeforeStop) {
+  DispatcherDestroyed_BeforeStop(std::move(resampler_));
+}
+
 // Simulate AudioOutputStream::Create() failure with a low latency stream and
 // ensure AudioOutputResampler falls back to the high latency path.
 TEST_F(AudioOutputResamplerTest, LowLatencyCreateFailedFallback) {
   MockAudioOutputStream stream(&manager_, params_);
   EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
       .Times(2)
       .WillOnce(Return(static_cast<AudioOutputStream*>(NULL)))
       .WillRepeatedly(Return(&stream));
   EXPECT_CALL(stream, Open())
       .WillOnce(Return(true));
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &stream);
 }
 
 // Simulate AudioOutputStream::Open() failure with a low latency stream and
 // ensure AudioOutputResampler falls back to the high latency path.
 TEST_F(AudioOutputResamplerTest, LowLatencyOpenFailedFallback) {
   MockAudioOutputStream failed_stream(&manager_, params_);
   MockAudioOutputStream okay_stream(&manager_, params_);
   EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
       .Times(2)
       .WillOnce(Return(&failed_stream))
       .WillRepeatedly(Return(&okay_stream));
   EXPECT_CALL(failed_stream, Open())
       .WillOnce(Return(false));
   EXPECT_CALL(failed_stream, Close())
       .Times(1);
   EXPECT_CALL(okay_stream, Open())
       .WillOnce(Return(true));
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &okay_stream);
 }
 
 // Simulate failures to open both the low latency and the fallback high latency
 // stream and ensure AudioOutputResampler falls back to a fake stream.
 TEST_F(AudioOutputResamplerTest, HighLatencyFallbackFailed) {
   MockAudioOutputStream okay_stream(&manager_, params_);
 
 // Only Windows has a high latency output driver that is not the same as the low
@@ skipping 16 matching lines @@
                         testing::Property(&AudioParameters::sample_rate,
                                           params_.sample_rate()),
                         testing::Property(&AudioParameters::frames_per_buffer,
                                           params_.frames_per_buffer())),
                   _, _))
       .Times(1)
       .WillOnce(Return(&okay_stream));
   EXPECT_CALL(okay_stream, Open())
       .WillOnce(Return(true));
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &okay_stream);
 }
 
 // Simulate failures to open both the low latency, the fallback high latency
 // stream, and the fake audio output stream and ensure AudioOutputResampler
 // terminates normally.
 TEST_F(AudioOutputResamplerTest, AllFallbackFailed) {
 // Only Windows has a high latency output driver that is not the same as the low
 // latency path.
 #if defined(OS_WIN)
   static const int kFallbackCount = 3;
 #else
   static const int kFallbackCount = 2;
 #endif
   EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
       .Times(kFallbackCount)
       .WillRepeatedly(Return(static_cast<AudioOutputStream*>(NULL)));
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy = resampler_->CreateStreamProxy();
   EXPECT_FALSE(proxy->Open());
   proxy->Close();
 }
 
 // Simulate an eventual OpenStream() failure; i.e. successful OpenStream() calls
 // eventually followed by one which fails; root cause of http://crbug.com/150619
 TEST_F(AudioOutputResamplerTest, LowLatencyOpenEventuallyFails) {
   MockAudioOutputStream stream1(&manager_, params_);
   MockAudioOutputStream stream2(&manager_, params_);
 
   // Setup the mock such that all three streams are successfully created.
   EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))
       .WillOnce(Return(&stream1))
       .WillOnce(Return(&stream2))
       .WillRepeatedly(Return(static_cast<AudioOutputStream*>(NULL)));
 
   // Stream1 should be able to successfully open and start.
   EXPECT_CALL(stream1, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(stream1, SetVolume(_))
       .Times(1);
 
   // Stream2 should also be able to successfully open and start.
   EXPECT_CALL(stream2, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(stream2, SetVolume(_))
       .Times(1);
 
   // Open and start the first proxy and stream.
-  AudioOutputProxy* proxy1 = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy1 = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy1->Open());
   proxy1->Start(&callback_);
   OnStart();
 
   // Open and start the second proxy and stream.
-  AudioOutputProxy* proxy2 = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy2 = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy2->Open());
   proxy2->Start(&callback_);
   OnStart();
 
   // Attempt to open the third stream which should fail.
-  AudioOutputProxy* proxy3 = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy3 = resampler_->CreateStreamProxy();
   EXPECT_FALSE(proxy3->Open());
   proxy3->Close();
 
   // Perform the required Stop()/Close() shutdown dance for each proxy.  Under
   // the hood each proxy should correctly call CloseStream() if OpenStream()
   // succeeded or not.
   proxy2->Stop();
   CloseAndWaitForCloseTimer(proxy2, &stream2);
 
   proxy1->Stop();
@@ skipping 25 matching lines @@
               MakeAudioOutputStream(
                   AllOf(testing::Property(&AudioParameters::format,
                                           AudioParameters::AUDIO_FAKE),
                         testing::Property(&AudioParameters::sample_rate,
                                           params_.sample_rate()),
                         testing::Property(&AudioParameters::frames_per_buffer,
                                           params_.frames_per_buffer())),
                   _, _))
       .WillOnce(Return(&fake_stream));
   EXPECT_CALL(fake_stream, Open()).WillOnce(Return(true));
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
+  AudioOutputProxy* proxy = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &fake_stream);
 
   // Once all proxies have been closed, AudioOutputResampler will start the
   // reinitialization timer and execute it after the close delay elapses.
   base::RunLoop run_loop;
   message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, run_loop.QuitClosure(),
       base::TimeDelta::FromMilliseconds(2 * kTestCloseDelayMs));
   run_loop.Run();
 
   // Verify a non-fake stream can be created.
   MockAudioOutputStream real_stream(&manager_, params_);
   EXPECT_CALL(manager(),
               MakeAudioOutputStream(
                   testing::Property(&AudioParameters::format,
                                     testing::Ne(AudioParameters::AUDIO_FAKE)),
                   _, _))
       .WillOnce(Return(&real_stream));
 
   // Stream1 should be able to successfully open and start.
   EXPECT_CALL(real_stream, Open()).WillOnce(Return(true));
-  proxy = new AudioOutputProxy(resampler_.get());
+  proxy = resampler_->CreateStreamProxy();
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &real_stream);
 }
 
 }  // namespace media