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

content/renderer/media/webrtc_audio_device_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 "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.h"
@@ skipping 87 matching lines @@
   }
 
   return true;
 }
 
 // Utility method which initializes the audio capturer contained in the
 // WebRTC audio device. This method should be used in tests where
 // HardwareSampleRatesAreValid() has been called and returned true.
 bool InitializeCapturer(WebRtcAudioDeviceImpl* webrtc_audio_device) {
   // Access the capturer owned and created by the audio device.
-  WebRtcAudioCapturer* capturer = webrtc_audio_device->capturer();
+  WebRtcAudioCapturer* capturer = webrtc_audio_device->capturer().get();
   if (!capturer)
     return false;
 
   media::AudioHardwareConfig* hardware_config =
       RenderThreadImpl::current()->GetAudioHardwareConfig();
 
   // Use native capture sample rate and channel configuration to get some
   // action in this test.
   int sample_rate = hardware_config->GetInputSampleRate();
   media::ChannelLayout channel_layout =
@@ skipping 171 matching lines @@
 // Returns the time in millisecond for sending packets to WebRtc for encoding,
 // signal processing, decoding and receiving them back.
 int RunWebRtcLoopbackTimeTest(media::AudioManager* manager,
                               bool enable_apm) {
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   EXPECT_TRUE(engine.valid());
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   EXPECT_TRUE(base.valid());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   EXPECT_EQ(0, err);
 
   // We use SetCaptureFormat() and SetRenderFormat() to configure the audio
   // parameters so that this test can run on machine without hardware device.
   const media::AudioParameters params = media::AudioParameters(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
       48000, 2, 480);
   WebRtcAudioCapturerSink* capturer_sink =
       static_cast<WebRtcAudioCapturerSink*>(webrtc_audio_device.get());
   capturer_sink->SetCaptureFormat(params);
@@ skipping 136 matching lines @@
       new WebRtcAudioDeviceImpl());
 
   // The capturer is not created until after the WebRtcAudioDeviceImpl has
   // been initialized.
   EXPECT_FALSE(InitializeCapturer(webrtc_audio_device.get()));
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
   EXPECT_EQ(0, err);
   EXPECT_EQ(0, base->Terminate());
 }
 
 // Verify that a call to webrtc::VoEBase::StartPlayout() starts audio output
 // with the correct set of parameters. A WebRtcAudioDeviceImpl instance will
 // be utilized to implement the actual audio path. The test registers a
 // webrtc::VoEExternalMedia implementation to hijack the output audio and
 // verify that streaming starts correctly.
@@ skipping 18 matching lines @@
       OnSetAudioStreamPlaying(_, 1, true)).Times(1);
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed"))).Times(1);
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
   scoped_refptr<WebRtcAudioRenderer> renderer =
       new WebRtcAudioRenderer(kRenderViewId);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer));
+  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
   ScopedWebRTCPtr<webrtc::VoEExternalMedia> external_media(engine.get());
   ASSERT_TRUE(external_media.valid());
 
   base::WaitableEvent event(false, false);
   scoped_ptr<WebRTCMediaProcessImpl> media_process(
@@ skipping 57 matching lines @@
   // for new interfaces, like OnSetAudioStreamRecording(). When done, add
   // EXPECT_CALL() macros here.
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
   webrtc_audio_device->capturer()->Start();
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
   ScopedWebRTCPtr<webrtc::VoEExternalMedia> external_media(engine.get());
   ASSERT_TRUE(external_media.valid());
@@ skipping 57 matching lines @@
       OnSetAudioStreamPlaying(_, 1, true)).Times(1);
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed"))).Times(1);
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
   scoped_refptr<WebRtcAudioRenderer> renderer =
       new WebRtcAudioRenderer(kRenderViewId);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer));
+  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
   EXPECT_EQ(0, base->StartPlayout(ch));
   renderer->Play();
 
   ScopedWebRTCPtr<webrtc::VoEFile> file(engine.get());
   ASSERT_TRUE(file.valid());
   int duration = 0;
@@ skipping 50 matching lines @@
       OnSetAudioStreamPlaying(_, 1, true));
   EXPECT_CALL(media_observer(),
       OnSetAudioStreamStatus(_, 1, StrEq("closed")));
   EXPECT_CALL(media_observer(),
       OnDeleteAudioStream(_, 1)).Times(AnyNumber());
 
   scoped_refptr<WebRtcAudioRenderer> renderer =
       new WebRtcAudioRenderer(kRenderViewId);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer));
+  EXPECT_TRUE(webrtc_audio_device->SetAudioRenderer(renderer.get()));
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
   webrtc_audio_device->capturer()->Start();
 
   ScopedWebRTCPtr<webrtc::VoEAudioProcessing> audio_processing(engine.get());
   ASSERT_TRUE(audio_processing.valid());
 #if defined(OS_ANDROID)
   // On Android, by default AGC is off.
   bool enabled = true;
@@ skipping 49 matching lines @@
     return;
 
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
 
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   ASSERT_TRUE(engine.valid());
 
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   ASSERT_TRUE(base.valid());
-  int err = base->Init(webrtc_audio_device);
+  int err = base->Init(webrtc_audio_device.get());
   ASSERT_EQ(0, err);
 
   EXPECT_TRUE(InitializeCapturer(webrtc_audio_device.get()));
   webrtc_audio_device->capturer()->Start();
 
   base::WaitableEvent event(false, false);
   scoped_ptr<MockWebRtcAudioCapturerSink> capturer_sink(
       new MockWebRtcAudioCapturerSink(&event));
-  WebRtcAudioCapturer* capturer = webrtc_audio_device->capturer();
+  WebRtcAudioCapturer* capturer = webrtc_audio_device->capturer().get();
   capturer->AddSink(capturer_sink.get());
 
   int ch = base->CreateChannel();
   EXPECT_NE(-1, ch);
 
   base::Time start_time = base::Time::Now();
   EXPECT_EQ(0, base->StartSend(ch));
 
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_timeout()));
   int delay = (base::Time::Now() - start_time).InMilliseconds();
@@ skipping 49 matching lines @@
                     "t", latency);
 }
 
 TEST_F(WebRTCAudioDeviceTest, WebRtcLoopbackTimeWithSignalProcessing) {
   int latency = RunWebRtcLoopbackTimeTest(audio_manager_.get(), true);
   PrintPerfResultMs("webrtc_loopback_with_signal_processing (100 packets)",
                     "t", latency);
 }
 
 }  // namespace content