diff --git a/api/media_stream_interface.h b/api/media_stream_interface.h
index 7e010289a0..9d336739e4 100644
--- a/api/media_stream_interface.h
+++ b/api/media_stream_interface.h
@@ -334,11 +334,38 @@ class MediaStreamInterface : public rtc::RefCountInterface,
       const std::string& track_id) = 0;
 
   // Takes ownership of added tracks.
-  // TODO(hta): Should take scoped_refptr rather than raw pointer.
-  virtual bool AddTrack(AudioTrackInterface* track) = 0;
-  virtual bool AddTrack(VideoTrackInterface* track) = 0;
-  virtual bool RemoveTrack(AudioTrackInterface* track) = 0;
-  virtual bool RemoveTrack(VideoTrackInterface* track) = 0;
+  // Note: Default implementations are for avoiding link time errors in
+  // implementations that mock this API.
+  // TODO(bugs.webrtc.org/13980): Remove default implementations.
+  virtual bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
+    RTC_CHECK_NOTREACHED();
+  }
+  virtual bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
+    RTC_CHECK_NOTREACHED();
+  }
+  virtual bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
+    RTC_CHECK_NOTREACHED();
+  }
+  virtual bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
+    RTC_CHECK_NOTREACHED();
+  }
+  // Deprecated: Should use scoped_refptr versions rather than pointers.
+  [[deprecated("Pass a scoped_refptr")]] virtual bool AddTrack(
+      AudioTrackInterface* track) {
+    return AddTrack(rtc::scoped_refptr<AudioTrackInterface>(track));
+  }
+  [[deprecated("Pass a scoped_refptr")]] virtual bool AddTrack(
+      VideoTrackInterface* track) {
+    return AddTrack(rtc::scoped_refptr<VideoTrackInterface>(track));
+  }
+  [[deprecated("Pass a scoped_refptr")]] virtual bool RemoveTrack(
+      AudioTrackInterface* track) {
+    return RemoveTrack(rtc::scoped_refptr<AudioTrackInterface>(track));
+  }
+  [[deprecated("Pass a scoped_refptr")]] virtual bool RemoveTrack(
+      VideoTrackInterface* track) {
+    return RemoveTrack(rtc::scoped_refptr<VideoTrackInterface>(track));
+  }
 
  protected:
   ~MediaStreamInterface() override = default;
diff --git a/pc/audio_rtp_receiver.cc b/pc/audio_rtp_receiver.cc
index 065814b9e1..3918c64f33 100644
--- a/pc/audio_rtp_receiver.cc
+++ b/pc/audio_rtp_receiver.cc
@@ -251,7 +251,7 @@ void AudioRtpReceiver::SetStreams(
       }
     }
     if (removed) {
-      existing_stream->RemoveTrack(track_.get());
+      existing_stream->RemoveTrack(audio_track());
     }
   }
   // Add remote track to any streams that are new.
@@ -265,7 +265,7 @@ void AudioRtpReceiver::SetStreams(
       }
     }
     if (added) {
-      stream->AddTrack(track_.get());
+      stream->AddTrack(audio_track());
     }
   }
   streams_ = streams;
diff --git a/pc/media_stream.cc b/pc/media_stream.cc
index 011d8abf55..df230e461a 100644
--- a/pc/media_stream.cc
+++ b/pc/media_stream.cc
@@ -36,21 +36,19 @@ rtc::scoped_refptr<MediaStream> MediaStream::Create(const std::string& id) {
 
 MediaStream::MediaStream(const std::string& id) : id_(id) {}
 
-bool MediaStream::AddTrack(AudioTrackInterface* track) {
-  return AddTrack<AudioTrackVector, AudioTrackInterface>(
-      &audio_tracks_, rtc::scoped_refptr<AudioTrackInterface>(track));
+bool MediaStream::AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
+  return AddTrack<AudioTrackVector, AudioTrackInterface>(&audio_tracks_, track);
 }
 
-bool MediaStream::AddTrack(VideoTrackInterface* track) {
-  return AddTrack<VideoTrackVector, VideoTrackInterface>(
-      &video_tracks_, rtc::scoped_refptr<VideoTrackInterface>(track));
+bool MediaStream::AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
+  return AddTrack<VideoTrackVector, VideoTrackInterface>(&video_tracks_, track);
 }
 
-bool MediaStream::RemoveTrack(AudioTrackInterface* track) {
+bool MediaStream::RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
   return RemoveTrack<AudioTrackVector>(&audio_tracks_, track);
 }
 
-bool MediaStream::RemoveTrack(VideoTrackInterface* track) {
+bool MediaStream::RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
   return RemoveTrack<VideoTrackVector>(&video_tracks_, track);
 }
 
@@ -82,8 +80,9 @@ bool MediaStream::AddTrack(TrackVector* tracks,
 }
 
 template <typename TrackVector>
-bool MediaStream::RemoveTrack(TrackVector* tracks,
-                              MediaStreamTrackInterface* track) {
+bool MediaStream::RemoveTrack(
+    TrackVector* tracks,
+    rtc::scoped_refptr<MediaStreamTrackInterface> track) {
   RTC_DCHECK(tracks != NULL);
   if (!track)
     return false;
diff --git a/pc/media_stream.h b/pc/media_stream.h
index 70e58f9760..c033cf6f35 100644
--- a/pc/media_stream.h
+++ b/pc/media_stream.h
@@ -27,10 +27,10 @@ class MediaStream : public Notifier<MediaStreamInterface> {
 
   std::string id() const override { return id_; }
 
-  bool AddTrack(AudioTrackInterface* track) override;
-  bool AddTrack(VideoTrackInterface* track) override;
-  bool RemoveTrack(AudioTrackInterface* track) override;
-  bool RemoveTrack(VideoTrackInterface* track) override;
+  bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
+  bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
+  bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) override;
+  bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) override;
   rtc::scoped_refptr<AudioTrackInterface> FindAudioTrack(
       const std::string& track_id) override;
   rtc::scoped_refptr<VideoTrackInterface> FindVideoTrack(
@@ -46,7 +46,8 @@ class MediaStream : public Notifier<MediaStreamInterface> {
   template <typename TrackVector, typename Track>
   bool AddTrack(TrackVector* Tracks, rtc::scoped_refptr<Track> track);
   template <typename TrackVector>
-  bool RemoveTrack(TrackVector* Tracks, MediaStreamTrackInterface* track);
+  bool RemoveTrack(TrackVector* Tracks,
+                   rtc::scoped_refptr<MediaStreamTrackInterface> track);
 
   const std::string id_;
   AudioTrackVector audio_tracks_;
diff --git a/pc/media_stream_proxy.h b/pc/media_stream_proxy.h
index 36069a4369..3e263bfd8b 100644
--- a/pc/media_stream_proxy.h
+++ b/pc/media_stream_proxy.h
@@ -31,10 +31,10 @@ PROXY_METHOD1(rtc::scoped_refptr<AudioTrackInterface>,
 PROXY_METHOD1(rtc::scoped_refptr<VideoTrackInterface>,
               FindVideoTrack,
               const std::string&)
-PROXY_METHOD1(bool, AddTrack, AudioTrackInterface*)
-PROXY_METHOD1(bool, AddTrack, VideoTrackInterface*)
-PROXY_METHOD1(bool, RemoveTrack, AudioTrackInterface*)
-PROXY_METHOD1(bool, RemoveTrack, VideoTrackInterface*)
+PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<AudioTrackInterface>)
+PROXY_METHOD1(bool, AddTrack, rtc::scoped_refptr<VideoTrackInterface>)
+PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<AudioTrackInterface>)
+PROXY_METHOD1(bool, RemoveTrack, rtc::scoped_refptr<VideoTrackInterface>)
 PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
 PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
 END_PROXY_MAP(MediaStream)
diff --git a/pc/media_stream_unittest.cc b/pc/media_stream_unittest.cc
index 7224c514a6..a1146a347a 100644
--- a/pc/media_stream_unittest.cc
+++ b/pc/media_stream_unittest.cc
@@ -66,10 +66,10 @@ class MediaStreamTest : public ::testing::Test {
     ASSERT_TRUE(audio_track_.get() != NULL);
     EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track_->state());
 
-    EXPECT_TRUE(stream_->AddTrack(video_track_.get()));
-    EXPECT_FALSE(stream_->AddTrack(video_track_.get()));
-    EXPECT_TRUE(stream_->AddTrack(audio_track_.get()));
-    EXPECT_FALSE(stream_->AddTrack(audio_track_.get()));
+    EXPECT_TRUE(stream_->AddTrack(video_track_));
+    EXPECT_FALSE(stream_->AddTrack(video_track_));
+    EXPECT_TRUE(stream_->AddTrack(audio_track_));
+    EXPECT_FALSE(stream_->AddTrack(audio_track_));
   }
 
   void ChangeTrack(MediaStreamTrackInterface* track) {
@@ -122,19 +122,19 @@ TEST_F(MediaStreamTest, RemoveTrack) {
 
   EXPECT_CALL(observer, OnChanged()).Times(Exactly(2));
 
-  EXPECT_TRUE(stream_->RemoveTrack(audio_track_.get()));
-  EXPECT_FALSE(stream_->RemoveTrack(audio_track_.get()));
+  EXPECT_TRUE(stream_->RemoveTrack(audio_track_));
+  EXPECT_FALSE(stream_->RemoveTrack(audio_track_));
   EXPECT_EQ(0u, stream_->GetAudioTracks().size());
   EXPECT_EQ(0u, stream_->GetAudioTracks().size());
 
-  EXPECT_TRUE(stream_->RemoveTrack(video_track_.get()));
-  EXPECT_FALSE(stream_->RemoveTrack(video_track_.get()));
+  EXPECT_TRUE(stream_->RemoveTrack(video_track_));
+  EXPECT_FALSE(stream_->RemoveTrack(video_track_));
 
   EXPECT_EQ(0u, stream_->GetVideoTracks().size());
   EXPECT_EQ(0u, stream_->GetVideoTracks().size());
 
-  EXPECT_FALSE(stream_->RemoveTrack(static_cast<AudioTrackInterface*>(NULL)));
-  EXPECT_FALSE(stream_->RemoveTrack(static_cast<VideoTrackInterface*>(NULL)));
+  EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<AudioTrackInterface>()));
+  EXPECT_FALSE(stream_->RemoveTrack(rtc::scoped_refptr<VideoTrackInterface>()));
 }
 
 TEST_F(MediaStreamTest, ChangeVideoTrack) {
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 104e3f41ea..3c146f7acc 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -549,14 +549,14 @@ rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
       rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
                                      nullptr));
-      stream->AddTrack(audio_track.get());
+      stream->AddTrack(audio_track);
 
       // Add a local video track.
       rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
           webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
                                      webrtc::FakeVideoTrackSource::Create(),
                                      rtc::Thread::Current()));
-      stream->AddTrack(video_track.get());
+      stream->AddTrack(video_track);
     }
 
     local_collection->AddStream(stream);
@@ -830,7 +830,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
   void AddVideoStream(const std::string& label) {
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
-    stream->AddTrack(CreateVideoTrack(label + "v0").get());
+    stream->AddTrack(CreateVideoTrack(label + "v0"));
     ASSERT_TRUE(pc_->AddStream(stream.get()));
   }
 
@@ -849,7 +849,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
   void AddAudioStream(const std::string& label) {
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(label));
-    stream->AddTrack(CreateAudioTrack(label + "a0").get());
+    stream->AddTrack(CreateAudioTrack(label + "a0"));
     ASSERT_TRUE(pc_->AddStream(stream.get()));
   }
 
@@ -859,8 +859,8 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
     // Create a local stream.
     rtc::scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(stream_id));
-    stream->AddTrack(CreateAudioTrack(audio_track_label).get());
-    stream->AddTrack(CreateVideoTrack(video_track_label).get());
+    stream->AddTrack(CreateAudioTrack(audio_track_label));
+    stream->AddTrack(CreateVideoTrack(video_track_label));
     ASSERT_TRUE(pc_->AddStream(stream.get()));
   }
 
@@ -1143,7 +1143,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
                      MediaStreamInterface* stream) {
     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         webrtc::AudioTrack::Create(track_id, nullptr));
-    ASSERT_TRUE(stream->AddTrack(audio_track.get()));
+    ASSERT_TRUE(stream->AddTrack(audio_track));
   }
 
   void AddVideoTrack(const std::string& track_id,
@@ -1152,7 +1152,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
         webrtc::VideoTrack::Create(track_id,
                                    webrtc::FakeVideoTrackSource::Create(),
                                    rtc::Thread::Current()));
-    ASSERT_TRUE(stream->AddTrack(video_track.get()));
+    ASSERT_TRUE(stream->AddTrack(video_track));
   }
 
   std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() {
@@ -1463,7 +1463,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddStreams) {
   rtc::scoped_refptr<AudioTrackInterface> audio_track(
       pc_factory_->CreateAudioTrack(
           kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
-  stream->AddTrack(audio_track.get());
+  stream->AddTrack(audio_track);
   EXPECT_TRUE(pc_->AddStream(stream.get()));
   EXPECT_EQ(3u, pc_->local_streams()->count());
 
@@ -1806,7 +1806,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackAfterAddStream) {
   // Add video track to the audio-only stream.
   rtc::scoped_refptr<VideoTrackInterface> video_track(
       CreateVideoTrack("video_label"));
-  stream->AddTrack(video_track.get());
+  stream->AddTrack(video_track);
 
   std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@@ -1827,7 +1827,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackAfterAddStream) {
   MediaStreamInterface* stream = pc_->local_streams()->at(0);
 
   // Remove the video track.
-  stream->RemoveTrack(stream->GetVideoTracks()[0].get());
+  stream->RemoveTrack(stream->GetVideoTracks()[0]);
 
   std::unique_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@@ -2614,8 +2614,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackThenRejectMediaContent) {
   CreatePeerConnection(config);
   CreateAndSetRemoteOffer(GetSdpStringWithStream1());
   MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
-  remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get());
-  remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get());
+  remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
+  remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
 
   std::unique_ptr<SessionDescriptionInterface> local_answer(
       webrtc::CreateSessionDescription(SdpType::kAnswer,
@@ -2699,8 +2699,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB, RemoveAlreadyGoneRemoteStream) {
   CreatePeerConnection(config);
   CreateAndSetRemoteOffer(GetSdpStringWithStream1());
   MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
-  remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0].get());
-  remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0].get());
+  remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
+  remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
 
   CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
 
@@ -2969,8 +2969,8 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
   // Add a new MediaStream but with the same tracks as in the first stream.
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
       webrtc::MediaStream::Create(kStreams[1]));
-  stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0].get());
-  stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0].get());
+  stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
+  stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
   pc_->AddStream(stream_1.get());
 
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
@@ -3584,22 +3584,22 @@ TEST_F(PeerConnectionInterfaceTestPlanB,
       CreateAudioTrack("audio_track"));
   rtc::scoped_refptr<VideoTrackInterface> video_track(
       CreateVideoTrack("video_track"));
-  stream->AddTrack(audio_track.get());
+  stream->AddTrack(audio_track);
   EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
   observer_.renegotiation_needed_ = false;
 
   CreateOfferReceiveAnswer();
-  stream->AddTrack(video_track.get());
+  stream->AddTrack(video_track);
   EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
   observer_.renegotiation_needed_ = false;
 
   CreateOfferReceiveAnswer();
-  stream->RemoveTrack(audio_track.get());
+  stream->RemoveTrack(audio_track);
   EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
   observer_.renegotiation_needed_ = false;
 
   CreateOfferReceiveAnswer();
-  stream->RemoveTrack(video_track.get());
+  stream->RemoveTrack(video_track);
   EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
   observer_.renegotiation_needed_ = false;
 }
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index 910f0a4b47..82de9f0cb5 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -476,13 +476,15 @@ class RTCStatsCollectorWrapper {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
       if (add_stream) {
-        local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
+        local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+            static_cast<AudioTrackInterface*>(track.get())));
       }
     } else {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
       if (add_stream) {
-        local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
+        local_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
+            static_cast<VideoTrackInterface*>(track.get())));
       }
     }
 
@@ -507,11 +509,13 @@ class RTCStatsCollectorWrapper {
     if (media_type == cricket::MEDIA_TYPE_AUDIO) {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
-      remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
+      remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+          static_cast<AudioTrackInterface*>(track.get())));
     } else {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
-      remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
+      remote_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
+          static_cast<VideoTrackInterface*>(track.get())));
     }
 
     rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
@@ -1732,8 +1736,8 @@ TEST_F(RTCStatsCollectorTest,
   rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track =
       CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
                       MediaStreamTrackInterface::kEnded);
-  local_stream->AddTrack(
-      static_cast<AudioTrackInterface*>(local_audio_track.get()));
+  local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+      static_cast<AudioTrackInterface*>(local_audio_track.get())));
 
   cricket::VoiceSenderInfo voice_sender_info_ssrc1;
   voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
@@ -1788,8 +1792,8 @@ TEST_F(RTCStatsCollectorTest,
   rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio_track =
       CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID",
                       MediaStreamTrackInterface::kLive);
-  remote_stream->AddTrack(
-      static_cast<AudioTrackInterface*>(remote_audio_track.get()));
+  remote_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+      static_cast<AudioTrackInterface*>(remote_audio_track.get())));
 
   cricket::VoiceReceiverInfo voice_receiver_info;
   voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
@@ -1872,8 +1876,8 @@ TEST_F(RTCStatsCollectorTest,
   rtc::scoped_refptr<MediaStreamTrackInterface> local_video_track =
       CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID",
                       MediaStreamTrackInterface::kLive);
-  local_stream->AddTrack(
-      static_cast<VideoTrackInterface*>(local_video_track.get()));
+  local_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
+      static_cast<VideoTrackInterface*>(local_video_track.get())));
 
   cricket::VideoSenderInfo video_sender_info_ssrc1;
   video_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
@@ -1935,8 +1939,8 @@ TEST_F(RTCStatsCollectorTest,
   rtc::scoped_refptr<MediaStreamTrackInterface> remote_video_track_ssrc3 =
       CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3",
                       MediaStreamTrackInterface::kEnded);
-  remote_stream->AddTrack(
-      static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get()));
+  remote_stream->AddTrack(rtc::scoped_refptr<VideoTrackInterface>(
+      static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get())));
 
   cricket::VideoReceiverInfo video_receiver_info_ssrc3;
   video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo());
@@ -3186,8 +3190,8 @@ TEST_F(RTCStatsCollectorTest, CollectEchoReturnLossFromTrackAudioProcessor) {
       CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
                       MediaStreamTrackInterface::kEnded,
                       /*create_fake_audio_processor=*/true);
-  local_stream->AddTrack(
-      static_cast<AudioTrackInterface*>(local_audio_track.get()));
+  local_stream->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(
+      static_cast<AudioTrackInterface*>(local_audio_track.get())));
 
   cricket::VoiceSenderInfo voice_sender_info_ssrc1;
   voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 6b3f6e04bd..077be486a5 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -210,7 +210,7 @@ class RtpSenderReceiverTest
         FakeVideoTrackSource::Create(is_screencast));
     video_track_ =
         VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current());
-    EXPECT_TRUE(local_stream_->AddTrack(video_track_.get()));
+    EXPECT_TRUE(local_stream_->AddTrack(video_track_));
   }
 
   void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
@@ -218,7 +218,7 @@ class RtpSenderReceiverTest
   void CreateAudioRtpSender(
       const rtc::scoped_refptr<LocalAudioSource>& source) {
     audio_track_ = AudioTrack::Create(kAudioTrackId, source);
-    EXPECT_TRUE(local_stream_->AddTrack(audio_track_.get()));
+    EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
     std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
         std::make_unique<MockSetStreamsObserver>();
     audio_rtp_sender_ =
@@ -897,7 +897,7 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersBeforeNegotiation) {
 
 TEST_F(RtpSenderReceiverTest, AudioSenderInitParametersMovedAfterNegotiation) {
   audio_track_ = AudioTrack::Create(kAudioTrackId, nullptr);
-  EXPECT_TRUE(local_stream_->AddTrack(audio_track_.get()));
+  EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
 
   std::unique_ptr<MockSetStreamsObserver> set_streams_observer =
       std::make_unique<MockSetStreamsObserver>();
diff --git a/pc/rtp_transmission_manager.cc b/pc/rtp_transmission_manager.cc
index 1e9443f04d..0edc09963f 100644
--- a/pc/rtp_transmission_manager.cc
+++ b/pc/rtp_transmission_manager.cc
@@ -553,7 +553,7 @@ void RtpTransmissionManager::OnRemoteSenderRemoved(
     rtc::scoped_refptr<AudioTrackInterface> audio_track =
         stream->FindAudioTrack(sender_info.sender_id);
     if (audio_track) {
-      stream->RemoveTrack(audio_track.get());
+      stream->RemoveTrack(audio_track);
     }
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     // Stopping or destroying a VideoRtpReceiver will end the
@@ -564,7 +564,7 @@ void RtpTransmissionManager::OnRemoteSenderRemoved(
     if (video_track) {
       // There's no guarantee the track is still available, e.g. the track may
       // have been removed from the stream by an application.
-      stream->RemoveTrack(video_track.get());
+      stream->RemoveTrack(video_track);
     }
   } else {
     RTC_DCHECK_NOTREACHED() << "Invalid media type";
diff --git a/pc/stats_collector_unittest.cc b/pc/stats_collector_unittest.cc
index 06c43c1835..5af8be771a 100644
--- a/pc/stats_collector_unittest.cc
+++ b/pc/stats_collector_unittest.cc
@@ -774,32 +774,32 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
   // stream, which is created if necessary.
   void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc,
                              StatsCollectorForTest* stats) {
-    track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(),
-                                rtc::Thread::Current());
+    video_track_ = VideoTrack::Create(
+        kLocalTrackId, FakeVideoTrackSource::Create(), rtc::Thread::Current());
     if (GetParam()) {
       if (!stream_)
         stream_ = MediaStream::Create("streamid");
-      stream_->AddTrack(track_.get());
+      stream_->AddTrack(video_track());
       stats->AddStream(stream_.get());
     } else {
-      stats->AddTrack(track_.get());
+      stats->AddTrack(video_track_.get());
     }
-    pc->AddSender(CreateMockSender(track_, kSsrcOfTrack));
+    pc->AddSender(CreateMockSender(video_track_, kSsrcOfTrack));
   }
 
   // Adds a incoming video track with a given SSRC into the stats.
   void AddIncomingVideoTrack(FakePeerConnectionForStats* pc,
                              StatsCollectorForTest* stats) {
-    track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(),
-                                rtc::Thread::Current());
+    video_track_ = VideoTrack::Create(
+        kRemoteTrackId, FakeVideoTrackSource::Create(), rtc::Thread::Current());
     if (GetParam()) {
       stream_ = MediaStream::Create("streamid");
-      stream_->AddTrack(track_.get());
+      stream_->AddTrack(video_track());
       stats->AddStream(stream_.get());
     } else {
-      stats->AddTrack(track_.get());
+      stats->AddTrack(video_track_.get());
     }
-    pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack));
+    pc->AddReceiver(CreateMockReceiver(video_track_, kSsrcOfTrack));
   }
 
   // Adds a outgoing audio track with a given SSRC into the stats,
@@ -813,7 +813,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
     if (GetParam()) {
       if (!stream_)
         stream_ = MediaStream::Create("streamid");
-      stream_->AddTrack(audio_track_.get());
+      stream_->AddTrack(audio_track());
       stats->AddStream(stream_.get());
     } else {
       stats->AddTrack(audio_track_.get());
@@ -828,7 +828,7 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
     if (GetParam()) {
       if (stream_ == nullptr)
         stream_ = MediaStream::Create("streamid");
-      stream_->AddTrack(audio_track_.get());
+      stream_->AddTrack(audio_track());
       stats->AddStream(stream_.get());
     } else {
       stats->AddTrack(audio_track_.get());
@@ -836,8 +836,11 @@ class StatsCollectorTrackTest : public StatsCollectorTest,
     pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
   }
 
+  rtc::scoped_refptr<AudioTrackInterface> audio_track() { return audio_track_; }
+  rtc::scoped_refptr<VideoTrackInterface> video_track() { return video_track_; }
+
   rtc::scoped_refptr<MediaStream> stream_;
-  rtc::scoped_refptr<VideoTrack> track_;
+  rtc::scoped_refptr<VideoTrack> video_track_;
   rtc::scoped_refptr<FakeAudioTrack> audio_track_;
 };
 
@@ -1111,7 +1114,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
 
   // Get report for the specific `track`.
   reports.clear();
-  stats->GetStats(track_.get(), &reports);
+  stats->GetStats(video_track_.get(), &reports);
   // `reports` should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE(3u, reports.size());
@@ -1480,7 +1483,7 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
   stream_ = MediaStream::Create("streamid");
   auto local_track =
       rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
-  stream_->AddTrack(local_track.get());
+  stream_->AddTrack(rtc::scoped_refptr<AudioTrackInterface>(local_track.get()));
   pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
   if (GetParam()) {
     stats->AddStream(stream_.get());
@@ -1490,9 +1493,9 @@ TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
   // Create a remote stream with a remote audio track and adds it to the stats.
   rtc::scoped_refptr<MediaStream> remote_stream(
       MediaStream::Create("remotestreamid"));
-  auto remote_track =
+  rtc::scoped_refptr<AudioTrackInterface> remote_track =
       rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
-  remote_stream->AddTrack(remote_track.get());
+  remote_stream->AddTrack(remote_track);
   pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
   if (GetParam()) {
     stats->AddStream(remote_stream.get());
@@ -1661,9 +1664,10 @@ TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
   // Create a remote stream with a remote audio track and adds it to the stats.
   rtc::scoped_refptr<MediaStream> remote_stream(
       MediaStream::Create("remotestreamid"));
-  auto remote_track = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
+  rtc::scoped_refptr<AudioTrackInterface> remote_track =
+      rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
   pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
-  remote_stream->AddTrack(remote_track.get());
+  remote_stream->AddTrack(remote_track);
   stats->AddStream(remote_stream.get());
 
   VoiceSenderInfo voice_sender_info;
@@ -1745,7 +1749,7 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
   VerifyAudioTrackStats(audio_track_.get(), stats.get(), voice_info, &reports);
 
   // Remove the previous audio track from the stream.
-  stream_->RemoveTrack(audio_track_.get());
+  stream_->RemoveTrack(audio_track());
   stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
   pc->RemoveSender(sender);
 
@@ -1753,7 +1757,8 @@ TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
   static const std::string kNewTrackId = "new_track_id";
   auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId);
   pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
-  stream_->AddTrack(new_audio_track.get());
+  stream_->AddTrack(
+      rtc::scoped_refptr<AudioTrackInterface>(new_audio_track.get()));
 
   stats->AddLocalAudioTrack(new_audio_track.get(), kSsrcOfTrack);
   stats->InvalidateCache();
diff --git a/pc/test/peer_connection_test_wrapper.cc b/pc/test/peer_connection_test_wrapper.cc
index f6891cda9e..fb120cd7aa 100644
--- a/pc/test/peer_connection_test_wrapper.cc
+++ b/pc/test/peer_connection_test_wrapper.cc
@@ -334,7 +334,7 @@ PeerConnectionTestWrapper::GetUserMedia(
     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
                                                    source.get()));
-    stream->AddTrack(audio_track.get());
+    stream->AddTrack(audio_track);
   }
 
   if (video) {
@@ -351,7 +351,7 @@ PeerConnectionTestWrapper::GetUserMedia(
         peer_connection_factory_->CreateVideoTrack(videotrack_label,
                                                    source.get()));
 
-    stream->AddTrack(video_track.get());
+    stream->AddTrack(video_track);
   }
   return stream;
 }
diff --git a/pc/video_rtp_receiver.cc b/pc/video_rtp_receiver.cc
index a119415351..8e11625347 100644
--- a/pc/video_rtp_receiver.cc
+++ b/pc/video_rtp_receiver.cc
@@ -221,7 +221,7 @@ void VideoRtpReceiver::SetStreams(
       }
     }
     if (removed) {
-      existing_stream->RemoveTrack(track_.get());
+      existing_stream->RemoveTrack(video_track());
     }
   }
   // Add remote track to any streams that are new.
@@ -235,7 +235,7 @@ void VideoRtpReceiver::SetStreams(
       }
     }
     if (added) {
-      stream->AddTrack(track_.get());
+      stream->AddTrack(video_track());
     }
   }
   streams_ = streams;
diff --git a/sdk/android/src/jni/pc/media_stream.cc b/sdk/android/src/jni/pc/media_stream.cc
index c209317e8e..2f0be5d639 100644
--- a/sdk/android/src/jni/pc/media_stream.cc
+++ b/sdk/android/src/jni/pc/media_stream.cc
@@ -113,7 +113,8 @@ static jboolean JNI_MediaStream_AddAudioTrackToNativeStream(
     jlong pointer,
     jlong j_audio_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
-      reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
+      rtc::scoped_refptr<AudioTrackInterface>(
+          reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer)));
 }
 
 static jboolean JNI_MediaStream_AddVideoTrackToNativeStream(
@@ -121,21 +122,24 @@ static jboolean JNI_MediaStream_AddVideoTrackToNativeStream(
     jlong pointer,
     jlong j_video_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
-      reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
+      rtc::scoped_refptr<VideoTrackInterface>(
+          reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)));
 }
 
 static jboolean JNI_MediaStream_RemoveAudioTrack(JNIEnv* jni,
                                                  jlong pointer,
                                                  jlong j_audio_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
-      reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
+      rtc::scoped_refptr<AudioTrackInterface>(
+          reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer)));
 }
 
 static jboolean JNI_MediaStream_RemoveVideoTrack(JNIEnv* jni,
                                                  jlong pointer,
                                                  jlong j_video_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->RemoveTrack(
-      reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer));
+      rtc::scoped_refptr<VideoTrackInterface>(
+          reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)));
 }
 
 static ScopedJavaLocalRef<jstring> JNI_MediaStream_GetId(JNIEnv* jni,