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

content/renderer/media/rtc_peer_connection_handler_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 <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 69 matching lines @@
   virtual bool hasSelector() const OVERRIDE {
     return has_selector_;
   }
   virtual WebKit::WebMediaStream stream() const OVERRIDE {
     return stream_;
   }
   virtual WebKit::WebMediaStreamTrack component() const OVERRIDE {
     return component_;
   }
   virtual scoped_refptr<LocalRTCStatsResponse> createResponse() OVERRIDE {
-    DCHECK(!response_);
+    DCHECK(!response_.get());
     response_ = new talk_base::RefCountedObject<MockRTCStatsResponse>();
     return response_;
   }
 
   virtual void requestSucceeded(const LocalRTCStatsResponse* response)
       OVERRIDE {
     EXPECT_EQ(response, response_.get());
     request_succeeded_called_ = true;
   }
 
@@ skipping 136 matching lines @@
                             video_sources);
 
     scoped_refptr<webrtc::MediaStreamInterface> native_stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
     WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
     local_stream.audioSources(audio_tracks);
     const std::string audio_track_id = UTF16ToUTF8(audio_tracks[0].id());
     scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         mock_dependency_factory_->CreateLocalAudioTrack(audio_track_id,
                                                         NULL));
-    native_stream->AddTrack(audio_track);
+    native_stream->AddTrack(audio_track.get());
     WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
     local_stream.audioSources(video_tracks);
     const std::string video_track_id = UTF16ToUTF8(video_tracks[0].id());
     webrtc::VideoSourceInterface* source = NULL;
     scoped_refptr<webrtc::VideoTrackInterface> video_track(
         mock_dependency_factory_->CreateLocalVideoTrack(
             video_track_id, source));
-    native_stream->AddTrack(video_track);
+    native_stream->AddTrack(video_track.get());
 
-    local_stream.setExtraData(new MediaStreamExtraData(native_stream, true));
+    local_stream.setExtraData(
+        new MediaStreamExtraData(native_stream.get(), true));
     return local_stream;
   }
 
   // Creates a remote MediaStream and adds it to the mocked native
   // peer connection.
   scoped_refptr<webrtc::MediaStreamInterface>
   AddRemoteMockMediaStream(const std::string& stream_label,
                            const std::string& video_track_label,
                            const std::string& audio_track_label) {
     scoped_refptr<webrtc::MediaStreamInterface> stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
     if (!video_track_label.empty()) {
       webrtc::VideoSourceInterface* source = NULL;
       scoped_refptr<webrtc::VideoTrackInterface> video_track(
           mock_dependency_factory_->CreateLocalVideoTrack(
               video_track_label, source));
-      stream->AddTrack(video_track);
+      stream->AddTrack(video_track.get());
     }
     if (!audio_track_label.empty()) {
       scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           mock_dependency_factory_->CreateLocalAudioTrack(audio_track_label,
                                                           NULL));
-      stream->AddTrack(audio_track);
+      stream->AddTrack(audio_track.get());
     }
-    mock_peer_connection_->AddRemoteStream(stream);
+    mock_peer_connection_->AddRemoteStream(stream.get());
     return stream;
   }
 
   scoped_ptr<MockWebRTCPeerConnectionHandlerClient> mock_client_;
   scoped_ptr<MockMediaStreamDependencyFactory> mock_dependency_factory_;
   scoped_ptr<NiceMock<MockPeerConnectionTracker> > mock_tracker_;
   scoped_ptr<RTCPeerConnectionHandlerUnderTest> pc_handler_;
 
   // Weak reference to the mocked native peer connection implementation.
   MockPeerConnectionImpl* mock_peer_connection_;
@@ skipping 158 matching lines @@
   scoped_refptr<MockRTCStatsRequest> request(
       new talk_base::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(local_stream, tracks[0]);
   pc_handler_->getStats(request.get());
   EXPECT_EQ(1, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithRemoteSelector) {
   scoped_refptr<webrtc::MediaStreamInterface> stream(
       AddRemoteMockMediaStream("remote_stream", "video", "audio"));
-  pc_handler_->OnAddStream(stream);
+  pc_handler_->OnAddStream(stream.get());
   const WebKit::WebMediaStream& remote_stream = mock_client_->remote_stream();
 
   WebKit::WebVector<WebKit::WebMediaStreamTrack> tracks;
   remote_stream.audioSources(tracks);
   ASSERT_LE(1ul, tracks.size());
 
   scoped_refptr<MockRTCStatsRequest> request(
       new talk_base::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(remote_stream, tracks[0]);
   pc_handler_->getStats(request.get());
@@ skipping 176 matching lines @@
 
   EXPECT_CALL(*mock_tracker_.get(), TrackRemoveStream(
       pc_handler_.get(),
       testing::Property(&WebKit::WebMediaStream::label,
                         UTF8ToUTF16(remote_stream_label)),
       PeerConnectionTracker::SOURCE_REMOTE));
   EXPECT_CALL(*mock_client_.get(), didRemoveRemoteStream(
       testing::Property(&WebKit::WebMediaStream::label,
                         UTF8ToUTF16(remote_stream_label))));
 
-  pc_handler_->OnAddStream(remote_stream);
-  pc_handler_->OnRemoveStream(remote_stream);
+  pc_handler_->OnAddStream(remote_stream.get());
+  pc_handler_->OnRemoveStream(remote_stream.get());
 }
 
 // This test that WebKit is notified about remote track state changes.
 TEST_F(RTCPeerConnectionHandlerTest, RemoteTrackState) {
   std::string remote_stream_label("remote_stream");
   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 
   testing::InSequence sequence;
   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
       testing::Property(&WebKit::WebMediaStream::label,
                         UTF8ToUTF16(remote_stream_label))));
-  pc_handler_->OnAddStream(remote_stream);
+  pc_handler_->OnAddStream(remote_stream.get());
   const WebKit::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 
   WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
   webkit_stream.audioTracks(audio_tracks);
   EXPECT_EQ(WebKit::WebMediaStreamSource::ReadyStateLive,
             audio_tracks[0].source().readyState());
 
   WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
     webkit_stream.videoTracks(video_tracks);
   EXPECT_EQ(WebKit::WebMediaStreamSource::ReadyStateLive,
@@ skipping 11 matching lines @@
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddAudioTrackFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 
   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
       testing::Property(&WebKit::WebMediaStream::label,
                         UTF8ToUTF16(remote_stream_label))));
-  pc_handler_->OnAddStream(remote_stream);
+  pc_handler_->OnAddStream(remote_stream.get());
   const WebKit::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 
   WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
   webkit_stream.audioTracks(audio_tracks);
   EXPECT_EQ(1u, audio_tracks.size());
 
   // Remove the Webrtc audio track from the Webrtc MediaStream.
   scoped_refptr<webrtc::AudioTrackInterface> webrtc_track =
       remote_stream->GetAudioTracks()[0].get();
-  remote_stream->RemoveTrack(webrtc_track);
+  remote_stream->RemoveTrack(webrtc_track.get());
   WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_audio_tracks1;
   webkit_stream.audioTracks(modified_audio_tracks1);
   EXPECT_EQ(0u, modified_audio_tracks1.size());
 
   // Add the WebRtc audio track again.
-  remote_stream->AddTrack(webrtc_track);
+  remote_stream->AddTrack(webrtc_track.get());
   WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_audio_tracks2;
   webkit_stream.audioTracks(modified_audio_tracks2);
   EXPECT_EQ(1u, modified_audio_tracks2.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddVideoTrackFromRemoteStream) {
   std::string remote_stream_label("remote_stream");
   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "video"));
 
   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
       testing::Property(&WebKit::WebMediaStream::label,
                         UTF8ToUTF16(remote_stream_label))));
-  pc_handler_->OnAddStream(remote_stream);
+  pc_handler_->OnAddStream(remote_stream.get());
   const WebKit::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 
   WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
   webkit_stream.videoTracks(video_tracks);
   EXPECT_EQ(1u, video_tracks.size());
 
   // Remove the Webrtc video track from the Webrtc MediaStream.
   scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
       remote_stream->GetVideoTracks()[0].get();
-  remote_stream->RemoveTrack(webrtc_track);
+  remote_stream->RemoveTrack(webrtc_track.get());
   WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_video_tracks1;
   webkit_stream.videoTracks(modified_video_tracks1);
   EXPECT_EQ(0u, modified_video_tracks1.size());
 
   // Add the WebRtc video track again.
-  remote_stream->AddTrack(webrtc_track);
+  remote_stream->AddTrack(webrtc_track.get());
   WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_video_tracks2;
   webkit_stream.videoTracks(modified_video_tracks2);
   EXPECT_EQ(1u, modified_video_tracks2.size());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnIceCandidate) {
   testing::InSequence sequence;
   EXPECT_CALL(*mock_tracker_.get(),
               TrackAddIceCandidate(pc_handler_.get(), _,
                                    PeerConnectionTracker::SOURCE_LOCAL));
@@ skipping 45 matching lines @@
   EXPECT_CALL(*mock_tracker_.get(),
               TrackCreateDTMFSender(pc_handler_.get(),
                                     testing::Ref(tracks[0])));
 
   scoped_ptr<WebKit::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 }
 
 }  // namespace content