Remove implicit scoped_refptr operator T*

content/renderer/media/peer_connection_handler_jsep_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/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
@@ skipping 48 matching lines @@
     ASSERT_TRUE(mock_peer_connection_);
   }
 
   // Creates a WebKit local MediaStream.
   WebKit::WebMediaStreamDescriptor CreateLocalMediaStream(
       const std::string& stream_label) {
     std::string video_track_label("video-label");
     std::string audio_track_label("audio-label");
 
     talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream(
-        mock_dependency_factory_->CreateLocalMediaStream(stream_label));
+        mock_dependency_factory_->CreateLocalMediaStream(stream_label).get());
     talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
         mock_dependency_factory_->CreateLocalAudioTrack(audio_track_label,
-                                                        NULL));
-    native_stream->AddTrack(audio_track);
+                                                        NULL).get());
+    native_stream->AddTrack(audio_track.get());
     talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
         mock_dependency_factory_->CreateLocalVideoTrack(
-            video_track_label, 0));
-    native_stream->AddTrack(video_track);
+            video_track_label, 0).get());
+    native_stream->AddTrack(video_track.get());
 
     WebKit::WebVector<WebKit::WebMediaStreamSource> audio_sources(
         static_cast<size_t>(1));
     audio_sources[0].initialize(WebKit::WebString::fromUTF8(video_track_label),
                                 WebKit::WebMediaStreamSource::TypeAudio,
                                 WebKit::WebString::fromUTF8("audio_track"));
     WebKit::WebVector<WebKit::WebMediaStreamSource> video_sources(
         static_cast<size_t>(1));
     video_sources[0].initialize(WebKit::WebString::fromUTF8(video_track_label),
                                 WebKit::WebMediaStreamSource::TypeVideo,
                                 WebKit::WebString::fromUTF8("video_track"));
     WebKit::WebMediaStreamDescriptor local_stream;
     local_stream.initialize(UTF8ToUTF16(stream_label), audio_sources,
                             video_sources);
-    local_stream.setExtraData(new MediaStreamExtraData(native_stream));
+    local_stream.setExtraData(new MediaStreamExtraData(native_stream.get()));
     return local_stream;
   }
 
   // Creates a remote MediaStream and adds it to the mocked native
   // peer connection.
   talk_base::scoped_refptr<webrtc::MediaStreamInterface>
   AddRemoteMockMediaStream(const std::string& stream_label,
                            const std::string& video_track_label,
                            const std::string& audio_track_label) {
     // We use a local stream as a remote since for testing purposes we really
     // only need the MediaStreamInterface.
     talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface> stream(
-        mock_dependency_factory_->CreateLocalMediaStream(stream_label));
+        mock_dependency_factory_->CreateLocalMediaStream(stream_label).get());
     if (!video_track_label.empty()) {
       talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
           mock_dependency_factory_->CreateLocalVideoTrack(
-              video_track_label, 0));
-      stream->AddTrack(video_track);
+              video_track_label, 0).get());
+      stream->AddTrack(video_track.get());
     }
     if (!audio_track_label.empty()) {
       talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
           mock_dependency_factory_->CreateLocalAudioTrack(audio_track_label,
-                                                          NULL));
-      stream->AddTrack(audio_track);
+                                                          NULL).get());
+      stream->AddTrack(audio_track.get());
     }
-    mock_peer_connection_->AddRemoteStream(stream);
+    mock_peer_connection_->AddRemoteStream(stream.get());
     return stream;
   }
 
   scoped_ptr<MockWebPeerConnection00HandlerClient> mock_client_;
   scoped_ptr<MockMediaStreamDependencyFactory> mock_dependency_factory_;
   scoped_ptr<PeerConnectionHandlerJsepUnderTest> pc_handler_;
 
   // Weak reference to the mocked native peer connection implementation.
   MockPeerConnectionImpl* mock_peer_connection_;
 };
@@ skipping 92 matching lines @@
   WebKit::WebMediaStreamDescriptor local_stream(
       CreateLocalMediaStream(stream_label));
 
   pc_handler_->addStream(local_stream);
   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
 
   // On add stream. ( Remote stream received)
   std::string remote_stream_label("remote_stream");
   talk_base::scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
-  pc_handler_->OnAddStream(remote_stream);
+  pc_handler_->OnAddStream(remote_stream.get());
   EXPECT_EQ(remote_stream_label, mock_client_->stream_label());
 
   // Remove stream.
   WebKit::WebVector<WebKit::WebMediaStreamDescriptor> empty_streams(
       static_cast<size_t>(0));
   pc_handler_->removeStream(local_stream);
   EXPECT_EQ("", mock_peer_connection_->stream_label());
 
   // On remove stream.
-  pc_handler_->OnRemoveStream(remote_stream);
+  pc_handler_->OnRemoveStream(remote_stream.get());
   EXPECT_TRUE(mock_client_->stream_label().empty());
 
   // Add stream again.
   pc_handler_->addStream(local_stream);
   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
 
   // On state change.
   mock_peer_connection_->SetReadyState(
       webrtc::PeerConnectionInterface::kActive);
   webrtc::PeerConnectionObserver::StateType state =
@@ skipping 40 matching lines @@
   talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
       AddRemoteMockMediaStream(stream_label_1, video_track_label_1,
                                audio_track_label_1));
   std::string stream_label_2 = "remote_stream_2";
   std::string video_track_label_2 = "remote_video_track_2";
   std::string audio_track_label_2 = "remote_audio_track_2";
   talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream_2(
       AddRemoteMockMediaStream(stream_label_2, video_track_label_2,
                                audio_track_label_2));
 
-  pc_handler_->OnAddStream(stream_1);
+  pc_handler_->OnAddStream(stream_1.get());
   EXPECT_EQ(stream_label_1, mock_client_->stream_label());
 
-  pc_handler_->OnAddStream(stream_2);
+  pc_handler_->OnAddStream(stream_2.get());
   EXPECT_EQ(stream_label_2, mock_client_->stream_label());
 }
 
 }  // namespace content