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

content/renderer/media/webrtc/media_stream_track_metrics_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 "content/renderer/media/webrtc/media_stream_track_metrics.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
@@ skipping 117 matching lines @@
   // Remove vs. local track differs.
   EXPECT_NE(metrics_->MakeUniqueIdImpl(
                 42, "x", MediaStreamTrackMetrics::RECEIVED_STREAM),
             metrics_->MakeUniqueIdImpl(
                 42, "x", MediaStreamTrackMetrics::SENT_STREAM));
 }
 
 TEST_F(MediaStreamTrackMetricsTest, BasicRemoteStreams) {
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
-  stream_->AddTrack(audio);
-  stream_->AddTrack(video);
-  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  stream_->AddTrack(video.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
@@ skipping 11 matching lines @@
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionDisconnected);
 }
 
 TEST_F(MediaStreamTrackMetricsTest, BasicLocalStreams) {
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
-  stream_->AddTrack(audio);
-  stream_->AddTrack(video);
-  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  stream_->AddTrack(video.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
@@ skipping 24 matching lines @@
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
 
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
-  stream_->AddTrack(audio);
-  stream_->AddTrack(video);
-  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  stream_->AddTrack(video.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 }
 
 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamAddedAferIceConnect) {
   metrics_->IceConnectionChange(
         PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
-  stream_->AddTrack(audio);
-  stream_->AddTrack(video);
-  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  stream_->AddTrack(video.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 }
 
 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamTrackAdded) {
   scoped_refptr<MockAudioTrackInterface> initial(MakeAudioTrack("initial"));
   scoped_refptr<MockAudioTrackInterface> added(MakeAudioTrack("added"));
-  stream_->AddTrack(initial);
-  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_);
+  stream_->AddTrack(initial.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("initial",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("added",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
-  stream_->AddTrack(added);
+  stream_->AddTrack(added.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("initial",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("added",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 }
 
 TEST_F(MediaStreamTrackMetricsTest, LocalStreamTrackRemoved) {
   scoped_refptr<MockAudioTrackInterface> first(MakeAudioTrack("first"));
   scoped_refptr<MockAudioTrackInterface> second(MakeAudioTrack("second"));
-  stream_->AddTrack(first);
-  stream_->AddTrack(second);
-  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  stream_->AddTrack(first.get());
+  stream_->AddTrack(second.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("first",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("second",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("first",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->RemoveTrack(first);
+  stream_->RemoveTrack(first.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("second",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 }
 
 TEST_F(MediaStreamTrackMetricsTest, LocalStreamModificationsBeforeAndAfter) {
   scoped_refptr<MockAudioTrackInterface> first(MakeAudioTrack("first"));
   scoped_refptr<MockAudioTrackInterface> second(MakeAudioTrack("second"));
-  stream_->AddTrack(first);
-  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  stream_->AddTrack(first.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 
   // This gets added after we start observing, but no lifetime message
   // should be sent at this point since the call is not connected. It
   // should get sent only once it gets connected.
-  stream_->AddTrack(second);
+  stream_->AddTrack(second.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("first",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("second",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("first",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("second",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 
   // This happens after the call is disconnected so no lifetime
   // message should be sent.
-  stream_->RemoveTrack(first);
+  stream_->RemoveTrack(first.get());
 }
 
 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamMultipleDisconnects) {
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
-  stream_->AddTrack(audio);
-  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionDisconnected);
   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
-  stream_->RemoveTrack(audio);
+  stream_->RemoveTrack(audio.get());
 }
 
 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamConnectDisconnectTwice) {
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
-  stream_->AddTrack(audio);
-  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 
   for (size_t i = 0; i < 2; ++i) {
     EXPECT_CALL(*metrics_,
                 SendLifetimeMessage("audio",
                                     MediaStreamTrackMetrics::AUDIO_TRACK,
                                     MediaStreamTrackMetrics::CONNECTED,
                                     MediaStreamTrackMetrics::RECEIVED_STREAM));
     metrics_->IceConnectionChange(
         PeerConnectionInterface::kIceConnectionConnected);
 
     EXPECT_CALL(*metrics_,
                 SendLifetimeMessage("audio",
                                     MediaStreamTrackMetrics::AUDIO_TRACK,
                                     MediaStreamTrackMetrics::DISCONNECTED,
                                     MediaStreamTrackMetrics::RECEIVED_STREAM));
     metrics_->IceConnectionChange(
         PeerConnectionInterface::kIceConnectionDisconnected);
   }
 
-  stream_->RemoveTrack(audio);
+  stream_->RemoveTrack(audio.get());
 }
 
 TEST_F(MediaStreamTrackMetricsTest, LocalStreamRemovedNoDisconnect) {
   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
-  stream_->AddTrack(audio);
-  stream_->AddTrack(video);
-  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  stream_->AddTrack(audio.get());
+  stream_->AddTrack(video.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  metrics_->RemoveStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  metrics_->RemoveStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 }
 
 TEST_F(MediaStreamTrackMetricsTest, LocalStreamLargerTest) {
   scoped_refptr<MockAudioTrackInterface> audio1(MakeAudioTrack("audio1"));
   scoped_refptr<MockAudioTrackInterface> audio2(MakeAudioTrack("audio2"));
   scoped_refptr<MockAudioTrackInterface> audio3(MakeAudioTrack("audio3"));
   scoped_refptr<MockVideoTrackInterface> video1(MakeVideoTrack("video1"));
   scoped_refptr<MockVideoTrackInterface> video2(MakeVideoTrack("video2"));
   scoped_refptr<MockVideoTrackInterface> video3(MakeVideoTrack("video3"));
-  stream_->AddTrack(audio1);
-  stream_->AddTrack(video1);
-  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  stream_->AddTrack(audio1.get());
+  stream_->AddTrack(video1.get());
+  metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio1",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video1",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   metrics_->IceConnectionChange(
       PeerConnectionInterface::kIceConnectionConnected);
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio2",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->AddTrack(audio2);
+  stream_->AddTrack(audio2.get());
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video2",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->AddTrack(video2);
+  stream_->AddTrack(video2.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio1",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->RemoveTrack(audio1);
+  stream_->RemoveTrack(audio1.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio3",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->AddTrack(audio3);
+  stream_->AddTrack(audio3.get());
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video3",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->AddTrack(video3);
+  stream_->AddTrack(video3.get());
 
   // Add back audio1
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio1",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::CONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->AddTrack(audio1);
+  stream_->AddTrack(audio1.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio2",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->RemoveTrack(audio2);
+  stream_->RemoveTrack(audio2.get());
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video2",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->RemoveTrack(video2);
+  stream_->RemoveTrack(video2.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio1",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->RemoveTrack(audio1);
+  stream_->RemoveTrack(audio1.get());
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video1",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  stream_->RemoveTrack(video1);
+  stream_->RemoveTrack(video1.get());
 
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("audio3",
                                   MediaStreamTrackMetrics::AUDIO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
   EXPECT_CALL(*metrics_,
               SendLifetimeMessage("video3",
                                   MediaStreamTrackMetrics::VIDEO_TRACK,
                                   MediaStreamTrackMetrics::DISCONNECTED,
                                   MediaStreamTrackMetrics::SENT_STREAM));
-  metrics_->RemoveStream(MediaStreamTrackMetrics::SENT_STREAM, stream_);
+  metrics_->RemoveStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 }
 
 }  // namespace content