Update media/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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 <string>
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
@@ skipping 465 matching lines @@
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(kStartRunTimeMs));
   }
 
  protected:
   AudioParameters resampler_params_;
   scoped_refptr<AudioOutputResampler> resampler_;
 };
 
 TEST_F(AudioOutputProxyTest, CreateAndClose) {
-  AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_);
+  AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_.get());
   proxy->Close();
 }
 
 TEST_F(AudioOutputResamplerTest, CreateAndClose) {
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   proxy->Close();
 }
 
 TEST_F(AudioOutputProxyTest, OpenAndClose) {
-  OpenAndClose(dispatcher_impl_);
+  OpenAndClose(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, OpenAndClose) {
-  OpenAndClose(resampler_);
+  OpenAndClose(resampler_.get());
 }
 
 // Create a stream, and verify that it is closed after kTestCloseDelayMs.
 // if it doesn't start playing.
 TEST_F(AudioOutputProxyTest, CreateAndWait) {
-  CreateAndWait(dispatcher_impl_);
+  CreateAndWait(dispatcher_impl_.get());
 }
 
 // Create a stream, and verify that it is closed after kTestCloseDelayMs.
 // if it doesn't start playing.
 TEST_F(AudioOutputResamplerTest, CreateAndWait) {
-  CreateAndWait(resampler_);
+  CreateAndWait(resampler_.get());
 }
 
 TEST_F(AudioOutputProxyTest, StartAndStop) {
-  StartAndStop(dispatcher_impl_);
+  StartAndStop(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, StartAndStop) {
-  StartAndStop(resampler_);
+  StartAndStop(resampler_.get());
 }
 
 TEST_F(AudioOutputProxyTest, CloseAfterStop) {
-  CloseAfterStop(dispatcher_impl_);
+  CloseAfterStop(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, CloseAfterStop) {
-  CloseAfterStop(resampler_);
+  CloseAfterStop(resampler_.get());
 }
 
-TEST_F(AudioOutputProxyTest, TwoStreams) {
-  TwoStreams(dispatcher_impl_);
-}
+TEST_F(AudioOutputProxyTest, TwoStreams) { TwoStreams(dispatcher_impl_.get()); }
 
-TEST_F(AudioOutputResamplerTest, TwoStreams) {
-  TwoStreams(resampler_);
-}
+TEST_F(AudioOutputResamplerTest, TwoStreams) { TwoStreams(resampler_.get()); }
 
 // Two streams: verify that second stream is allocated when the first
 // starts playing.
 TEST_F(AudioOutputProxyTest, TwoStreams_OnePlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
-  TwoStreams_OnePlaying(dispatcher_impl_);
+  TwoStreams_OnePlaying(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, TwoStreams_OnePlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
-  TwoStreams_OnePlaying(resampler_);
+  TwoStreams_OnePlaying(resampler_.get());
 }
 
 // Two streams, both are playing. Dispatcher should not open a third stream.
 TEST_F(AudioOutputProxyTest, TwoStreams_BothPlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
-  TwoStreams_BothPlaying(dispatcher_impl_);
+  TwoStreams_BothPlaying(dispatcher_impl_.get());
 }
 
 TEST_F(AudioOutputResamplerTest, TwoStreams_BothPlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
-  TwoStreams_BothPlaying(resampler_);
+  TwoStreams_BothPlaying(resampler_.get());
 }
 
-TEST_F(AudioOutputProxyTest, OpenFailed) {
-  OpenFailed(dispatcher_impl_);
-}
+TEST_F(AudioOutputProxyTest, OpenFailed) { OpenFailed(dispatcher_impl_.get()); }
 
 // Start() method failed.
 TEST_F(AudioOutputProxyTest, StartFailed) {
-  StartFailed(dispatcher_impl_);
+  StartFailed(dispatcher_impl_.get());
 }
 
-TEST_F(AudioOutputResamplerTest, StartFailed) {
-  StartFailed(resampler_);
-}
+TEST_F(AudioOutputResamplerTest, StartFailed) { StartFailed(resampler_.get()); }
 
 // 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));
   EXPECT_CALL(stream, Close())
       .Times(1);
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 // 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));
   EXPECT_CALL(okay_stream, Close())
       .Times(1);
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 // 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_);
 
@@ skipping 15 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));
   EXPECT_CALL(okay_stream, Close())
       .Times(1);
 
-  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 // 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_);
+  AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_FALSE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 // 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_);
@@ skipping 23 matching lines @@
       .Times(1);
 
   // Stream3 should fail on Open() (yet still be closed since
   // MakeAudioOutputStream returned a valid AudioOutputStream object).
   EXPECT_CALL(stream3, Open())
       .WillOnce(Return(false));
   EXPECT_CALL(stream3, Close())
       .Times(1);
 
   // Open and start the first proxy and stream.
-  AudioOutputProxy* proxy1 = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy1 = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy1->Open());
   proxy1->Start(&callback_);
   OnStart();
 
   // Open and start the second proxy and stream.
-  AudioOutputProxy* proxy2 = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy2 = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy2->Open());
   proxy2->Start(&callback_);
   OnStart();
 
   // Attempt to open the third stream which should fail.
-  AudioOutputProxy* proxy3 = new AudioOutputProxy(resampler_);
+  AudioOutputProxy* proxy3 = new AudioOutputProxy(resampler_.get());
   EXPECT_FALSE(proxy3->Open());
 
   // Perform the required Stop()/Close() shutdown dance for each proxy.  Under
   // the hood each proxy should correctly call CloseStream() if OpenStream()
   // succeeded or not.
   proxy3->Stop();
   proxy3->Close();
   proxy2->Stop();
   proxy2->Close();
   proxy1->Stop();
   proxy1->Close();
 
   // Wait for all of the messages to fly and then verify stream behavior.
   WaitForCloseTimer(kTestCloseDelayMs);
   EXPECT_TRUE(stream1.stop_called());
   EXPECT_TRUE(stream1.start_called());
   EXPECT_TRUE(stream2.stop_called());
   EXPECT_TRUE(stream2.start_called());
   EXPECT_FALSE(stream3.stop_called());
   EXPECT_FALSE(stream3.start_called());
 }
 
 }  // namespace media