Remove implicit conversions from scoped_refptr to T* in content/renderer/media/webrtc*

content/renderer/media/webrtc_audio_renderer_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/media_stream_audio_renderer.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
@@ skipping 73 matching lines @@
         mock_ipc_(new MockAudioOutputIPC()),
         mock_output_device_(new FakeAudioOutputDevice(
             scoped_ptr<media::AudioOutputIPC>(mock_ipc_),
             message_loop_->message_loop_proxy())),
         factory_(new MockAudioDeviceFactory()),
         source_(new MockAudioRendererSource()),
         stream_(new rtc::RefCountedObject<MockMediaStream>("label")),
         renderer_(new WebRtcAudioRenderer(stream_, 1, 1, 1, 44100, 441)) {
     EXPECT_CALL(*factory_.get(), CreateOutputDevice(1))
         .WillOnce(Return(mock_output_device_));
-    EXPECT_CALL(*mock_output_device_, Start());
+    EXPECT_CALL(*mock_output_device_.get(), Start());
     EXPECT_TRUE(renderer_->Initialize(source_.get()));
     renderer_proxy_ = renderer_->CreateSharedAudioRendererProxy(stream_);
   }
 
   // Used to construct |mock_output_device_|.
   scoped_ptr<base::MessageLoopForIO> message_loop_;
   MockAudioOutputIPC* mock_ipc_;  // Owned by AudioOuputDevice.
 
   scoped_refptr<FakeAudioOutputDevice> mock_output_device_;
   scoped_ptr<MockAudioDeviceFactory> factory_;
   scoped_ptr<MockAudioRendererSource> source_;
   scoped_refptr<webrtc::MediaStreamInterface> stream_;
   scoped_refptr<WebRtcAudioRenderer> renderer_;
   scoped_refptr<MediaStreamAudioRenderer> renderer_proxy_;
 };
 
 // Verify that the renderer will be stopped if the only proxy is stopped.
 TEST_F(WebRtcAudioRendererTest, StopRenderer) {
   renderer_proxy_->Start();
 
   // |renderer_| has only one proxy, stopping the proxy should stop the sink of
   // |renderer_|.
-  EXPECT_CALL(*mock_output_device_, Stop());
+  EXPECT_CALL(*mock_output_device_.get(), Stop());
   EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
   renderer_proxy_->Stop();
 }
 
 // Verify that the renderer will not be stopped unless the last proxy is
 // stopped.
 TEST_F(WebRtcAudioRendererTest, MultipleRenderers) {
   renderer_proxy_->Start();
 
   // Create a vector of renderer proxies from the |renderer_|.
   std::vector<scoped_refptr<MediaStreamAudioRenderer> > renderer_proxies_;
   static const int kNumberOfRendererProxy = 5;
   for (int i = 0; i < kNumberOfRendererProxy; ++i) {
     scoped_refptr<MediaStreamAudioRenderer> renderer_proxy(
         renderer_->CreateSharedAudioRendererProxy(stream_));
     renderer_proxy->Start();
     renderer_proxies_.push_back(renderer_proxy);
   }
 
   // Stop the |renderer_proxy_| should not stop the sink since it is used by
   // other proxies.
-  EXPECT_CALL(*mock_output_device_, Stop()).Times(0);
+  EXPECT_CALL(*mock_output_device_.get(), Stop()).Times(0);
   renderer_proxy_->Stop();
 
   for (int i = 0; i < kNumberOfRendererProxy; ++i) {
     if (i != kNumberOfRendererProxy -1) {
-      EXPECT_CALL(*mock_output_device_, Stop()).Times(0);
+      EXPECT_CALL(*mock_output_device_.get(), Stop()).Times(0);
     } else {
       // When the last proxy is stopped, the sink will stop.
       EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
-      EXPECT_CALL(*mock_output_device_, Stop());
+      EXPECT_CALL(*mock_output_device_.get(), Stop());
     }
     renderer_proxies_[i]->Stop();
   }
 }
 
 }  // namespace content