WebRtcMediaStreamAdapter using WebRtcMediaStreamTrackMap.

Make the WebRtcMediaStreamAdapter, which represent local streams,
use the WebRtcMediaStreamTrackMap and AdapterRef classes for the
handling of initializing, getting and uninitializing local tracks.

WebRtcMediaStreamTrackAdapter is updated to allow local tracks from
non-local sources (removed DCHECKs) which happens when redirecting
remote sources as local streams.

This is one step closer to decoupling streams and tracks.

The same thing will be done in a follow-up CL for the remote streams
case, RemoteMediaStreamImpl.

BUG=705901, 700916

Review-Url: https://codereview.chromium.org/2897603004
Cr-Commit-Position: refs/heads/master@{#478592}

content/renderer/media/peer_connection_tracker_unittest.cc

@@ -4,10 +4,12 @@
 
 #include "content/renderer/media/peer_connection_tracker.h"
 
+#include "base/message_loop/message_loop.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/public/test/mock_render_thread.h"
 #include "content/renderer/media/mock_web_rtc_peer_connection_handler_client.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
+#include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "ipc/ipc_message_macros.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -43,20 +45,27 @@ bool MockSendTargetThread::OnMessageReceived(const IPC::Message& msg) {
 
 class MockPeerConnectionHandler : public RTCPeerConnectionHandler {
  public:
-  MockPeerConnectionHandler() : RTCPeerConnectionHandler(&client_, nullptr) {}
+  MockPeerConnectionHandler()
+      : RTCPeerConnectionHandler(&client_, &dependency_factory_) {}
   MOCK_METHOD0(CloseClientPeerConnection, void());
 
  private:
+  MockPeerConnectionDependencyFactory dependency_factory_;
   MockWebRTCPeerConnectionHandlerClient client_;
 };
 
+class PeerConnectionTrackerTest : public ::testing::Test {
+ private:
+  base::MessageLoop message_loop_;
+};
+
 }  // namespace
 
-TEST(PeerConnectionTrackerTest, CreatingObject) {
+TEST_F(PeerConnectionTrackerTest, CreatingObject) {
   PeerConnectionTracker tracker;
 }
 
-TEST(PeerConnectionTrackerTest, TrackCreateOffer) {
+TEST_F(PeerConnectionTrackerTest, TrackCreateOffer) {
   PeerConnectionTracker tracker;
   // Note: blink::WebRTCOfferOptions is not mockable. So we can't write
   // tests for anything but a null options parameter.
@@ -78,7 +87,7 @@ TEST(PeerConnectionTrackerTest, TrackCreateOffer) {
   tracker.TrackCreateOffer(&pc_handler, options);
 }
 
-TEST(PeerConnectionTrackerTest, OnSuspend) {
+TEST_F(PeerConnectionTrackerTest, OnSuspend) {
   PeerConnectionTracker tracker;
   // Initialization stuff.
   MockPeerConnectionHandler pc_handler;

content/renderer/media/rtc_peer_connection_handler.cc

@@ -1119,6 +1119,9 @@ RTCPeerConnectionHandler::RTCPeerConnectionHandler(
     : client_(client),
       is_closed_(false),
       dependency_factory_(dependency_factory),
+      track_adapter_map_(new WebRtcMediaStreamTrackAdapterMap(
+          dependency_factory_,
+          base::ThreadTaskRunnerHandle::Get())),
       weak_factory_(this) {
   CHECK(client_);
   GetPeerConnectionHandlers()->insert(this);
@@ -1553,8 +1556,8 @@ bool RTCPeerConnectionHandler::AddStream(
 
   PerSessionWebRTCAPIMetrics::GetInstance()->IncrementStreamCounter();
 
-  local_streams_.push_back(
-      base::MakeUnique<WebRtcMediaStreamAdapter>(stream, dependency_factory_));
+  local_streams_.push_back(base::MakeUnique<WebRtcMediaStreamAdapter>(
+      dependency_factory_, track_adapter_map_, stream));
 
   webrtc::MediaStreamInterface* webrtc_stream =
       local_streams_.back()->webrtc_media_stream();

content/renderer/media/rtc_peer_connection_handler.h

@@ -21,6 +21,7 @@
 #include "base/threading/thread_checker.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/webrtc/media_stream_track_metrics.h"
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "ipc/ipc_platform_file.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandler.h"
@@ -260,6 +261,19 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
 
   blink::WebFrame* frame_ = nullptr;
 
+  // Map and owners of track adapters. Every track that is in use by the peer
+  // connection has an associated blink and webrtc layer representation of it.
+  // The map keeps track of the relationship between
+  // |blink::WebMediaStreamTrack|s and |webrtc::MediaStreamTrackInterface|s.
+  // Track adapters are created on the fly when a component (such as a stream)
+  // needs to reference it, and automatically disposed when there are no longer
+  // any components referencing it.
+  scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map_;
+  // Local stream adapters. Every stream that is in use by the peer connection
+  // has an associated blink and webrtc layer representation of it. This vector
+  // keeps track of the relationship between |blink::WebMediaStream|s and
+  // |webrtc::MediaStreamInterface|s. Streams are added and removed from the
+  // peer connection using |AddStream| and |RemoveStream|.
   std::vector<std::unique_ptr<WebRtcMediaStreamAdapter>> local_streams_;
 
   base::WeakPtr<PeerConnectionTracker> peer_connection_tracker_;

content/renderer/media/webrtc/webrtc_media_stream_adapter.cc

@@ -4,36 +4,36 @@
 
 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "content/renderer/media/media_stream_audio_track.h"
-#include "content/renderer/media/media_stream_track.h"
-#include "content/renderer/media/webrtc/media_stream_video_webrtc_sink.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
-#include "content/renderer/media/webrtc/processed_local_audio_source.h"
-#include "content/renderer/media/webrtc/webrtc_audio_sink.h"
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
-#include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 WebRtcMediaStreamAdapter::WebRtcMediaStreamAdapter(
-    const blink::WebMediaStream& web_stream,
-    PeerConnectionDependencyFactory* factory)
-    : web_stream_(web_stream),
-      factory_(factory) {
+    PeerConnectionDependencyFactory* factory,
+    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+    const blink::WebMediaStream& web_stream)
+    : factory_(factory),
+      track_adapter_map_(track_adapter_map),
+      web_stream_(web_stream) {
   webrtc_media_stream_ =
       factory_->CreateLocalMediaStream(web_stream.Id().Utf8());
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   web_stream_.AudioTracks(audio_tracks);
   for (blink::WebMediaStreamTrack& audio_track : audio_tracks)
-    AddAudioSinkToTrack(audio_track);
+    TrackAdded(audio_track);
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   web_stream_.VideoTracks(video_tracks);
   for (blink::WebMediaStreamTrack& video_track : video_tracks)
-    AddVideoSinkToTrack(video_track);
+    TrackAdded(video_track);
 
   MediaStream* const native_stream = MediaStream::GetMediaStream(web_stream_);
   native_stream->AddObserver(this);
@@ -47,105 +47,52 @@ WebRtcMediaStreamAdapter::~WebRtcMediaStreamAdapter() {
   web_stream_.AudioTracks(audio_tracks);
   for (blink::WebMediaStreamTrack& audio_track : audio_tracks)
     TrackRemoved(audio_track);
-  DCHECK(audio_sinks_.empty());
+
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   web_stream_.VideoTracks(video_tracks);
   for (blink::WebMediaStreamTrack& video_track : video_tracks)
     TrackRemoved(video_track);
-  DCHECK(video_sinks_.empty());
 }
 
 void WebRtcMediaStreamAdapter::TrackAdded(
-    const blink::WebMediaStreamTrack& track) {
-  if (track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio)
-    AddAudioSinkToTrack(track);
-  else
-    AddVideoSinkToTrack(track);
-}
-
-void WebRtcMediaStreamAdapter::TrackRemoved(
-    const blink::WebMediaStreamTrack& track) {
-  const std::string track_id = track.Id().Utf8();
-  if (track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) {
-    scoped_refptr<webrtc::AudioTrackInterface> webrtc_track =
-        make_scoped_refptr(
-            webrtc_media_stream_->FindAudioTrack(track_id).get());
-    if (!webrtc_track)
-      return;
-    webrtc_media_stream_->RemoveTrack(webrtc_track.get());
-
-    for (auto it = audio_sinks_.begin(); it != audio_sinks_.end(); ++it) {
-      if ((*it)->webrtc_audio_track() == webrtc_track.get()) {
-        if (auto* media_stream_track = MediaStreamAudioTrack::From(track))
-          media_stream_track->RemoveSink(it->get());
-        audio_sinks_.erase(it);
-        break;
-      }
-    }
+    const blink::WebMediaStreamTrack& web_track) {
+  std::string track_id = web_track.Id().Utf8();
+  DCHECK(adapter_refs_.find(track_id) == adapter_refs_.end());
+  bool is_audio_track =
+      (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio);
+  if (is_audio_track && !MediaStreamAudioTrack::From(web_track)) {
+    DLOG(ERROR) << "No native track for blink audio track.";
+    return;
+  }
+  std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> adapter_ref =
+      track_adapter_map_->GetOrCreateLocalTrackAdapter(web_track);
+  if (is_audio_track) {
+    webrtc_media_stream_->AddTrack(
+        static_cast<webrtc::AudioTrackInterface*>(adapter_ref->webrtc_track()));
   } else {
-    DCHECK_EQ(track.Source().GetType(),
-              blink::WebMediaStreamSource::kTypeVideo);
-    scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
-        make_scoped_refptr(
-            webrtc_media_stream_->FindVideoTrack(track_id).get());
-    if (!webrtc_track)
-      return;
-    webrtc_media_stream_->RemoveTrack(webrtc_track.get());
-
-    for (auto it = video_sinks_.begin(); it != video_sinks_.end(); ++it) {
-      if ((*it)->webrtc_video_track() == webrtc_track.get()) {
-        video_sinks_.erase(it);
-        break;
-      }
-    }
+    webrtc_media_stream_->AddTrack(
+        static_cast<webrtc::VideoTrackInterface*>(adapter_ref->webrtc_track()));
   }
+  adapter_refs_.insert(std::make_pair(track_id, std::move(adapter_ref)));
 }
 
-// TODO(hbos): Replace this code with |WebRtcMediaStreamTrackAdapter|.
-// crbug.com/705901
-void WebRtcMediaStreamAdapter::AddAudioSinkToTrack(
-    const blink::WebMediaStreamTrack& track) {
-  MediaStreamAudioTrack* native_track = MediaStreamAudioTrack::From(track);
-  if (!native_track) {
-    DLOG(ERROR) << "No native track for blink audio track.";
+void WebRtcMediaStreamAdapter::TrackRemoved(
+    const blink::WebMediaStreamTrack& web_track) {
+  std::string track_id = web_track.Id().Utf8();
+  auto it = adapter_refs_.find(track_id);
+  if (it == adapter_refs_.end()) {
+    // This can happen for audio tracks that don't have a source, these would
+    // never be added in the first place.
     return;
   }
-
-  // Non-WebRtc remote sources and local sources do not provide an instance of
-  // the webrtc::AudioSourceInterface, and also do not need references to the
-  // audio level calculator or audio processor passed to the sink.
-  webrtc::AudioSourceInterface* source_interface = nullptr;
-  WebRtcAudioSink* audio_sink =
-      new WebRtcAudioSink(track.Id().Utf8(), source_interface,
-                          factory_->GetWebRtcSignalingThread());
-
-  if (auto* media_stream_source = ProcessedLocalAudioSource::From(
-          MediaStreamAudioSource::From(track.Source()))) {
-    audio_sink->SetLevel(media_stream_source->audio_level());
-    // The sink only grabs stats from the audio processor. Stats are only
-    // available if audio processing is turned on. Therefore, only provide the
-    // sink a reference to the processor if audio processing is turned on.
-    if (auto processor = media_stream_source->audio_processor()) {
-      if (processor && processor->has_audio_processing())
-        audio_sink->SetAudioProcessor(processor);
-    }
+  if (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) {
+    webrtc_media_stream_->RemoveTrack(
+        static_cast<webrtc::AudioTrackInterface*>(it->second->webrtc_track()));
+  } else {
+    webrtc_media_stream_->RemoveTrack(
+        static_cast<webrtc::VideoTrackInterface*>(it->second->webrtc_track()));
   }
-
-  audio_sinks_.push_back(std::unique_ptr<WebRtcAudioSink>(audio_sink));
-  native_track->AddSink(audio_sink);
-  webrtc_media_stream_->AddTrack(audio_sink->webrtc_audio_track());
-}
-
-// TODO(hbos): Replace this code with |WebRtcMediaStreamTrackAdapter|.
-// crbug.com/705901
-void WebRtcMediaStreamAdapter::AddVideoSinkToTrack(
-    const blink::WebMediaStreamTrack& track) {
-  DCHECK_EQ(track.Source().GetType(), blink::WebMediaStreamSource::kTypeVideo);
-  MediaStreamVideoWebRtcSink* video_sink =
-      new MediaStreamVideoWebRtcSink(track, factory_);
-  video_sinks_.push_back(
-      std::unique_ptr<MediaStreamVideoWebRtcSink>(video_sink));
-  webrtc_media_stream_->AddTrack(video_sink->webrtc_video_track());
+  adapter_refs_.erase(it);
 }
 
 }  // namespace content

content/renderer/media/webrtc/webrtc_media_stream_adapter.h

@@ -5,21 +5,21 @@
 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_MEDIA_STREAM_ADAPTER_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_MEDIA_STREAM_ADAPTER_H_
 
+#include <map>
 #include <memory>
-#include <vector>
+#include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/media_stream.h"
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 
 namespace content {
 
 class PeerConnectionDependencyFactory;
-class MediaStreamVideoWebRtcSink;
-class WebRtcAudioSink;
 
 // WebRtcMediaStreamAdapter is an adapter between a blink::WebMediaStream
 // object and a webrtc MediaStreams that is currently sent on a PeerConnection.
@@ -32,8 +32,10 @@ class WebRtcAudioSink;
 class CONTENT_EXPORT WebRtcMediaStreamAdapter
     : NON_EXPORTED_BASE(public MediaStreamObserver) {
  public:
-  WebRtcMediaStreamAdapter(const blink::WebMediaStream& web_stream,
-                           PeerConnectionDependencyFactory* factory);
+  WebRtcMediaStreamAdapter(
+      PeerConnectionDependencyFactory* factory,
+      scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map,
+      const blink::WebMediaStream& web_stream);
   ~WebRtcMediaStreamAdapter() override;
 
   bool IsEqual(const blink::WebMediaStream& web_stream) const {
@@ -47,25 +49,32 @@ class CONTENT_EXPORT WebRtcMediaStreamAdapter
   const blink::WebMediaStream& web_stream() const { return web_stream_; }
 
  protected:
-  // MediaStreamObserver implementation.
-  void TrackAdded(const blink::WebMediaStreamTrack& track) override;
-  void TrackRemoved(const blink::WebMediaStreamTrack& track) override;
+  // MediaStreamObserver implementation. Also used as a helper functions when
+  // adding/removing all tracks in the constructor/destructor.
+  void TrackAdded(const blink::WebMediaStreamTrack& web_track) override;
+  void TrackRemoved(const blink::WebMediaStreamTrack& web_track) override;
 
  private:
-  void AddAudioSinkToTrack(const blink::WebMediaStreamTrack& track);
-  void AddVideoSinkToTrack(const blink::WebMediaStreamTrack& track);
-
-  const blink::WebMediaStream web_stream_;
-
   // Pointer to a PeerConnectionDependencyFactory, owned by the RenderThread.
   // It's valid for the lifetime of RenderThread.
   PeerConnectionDependencyFactory* const factory_;
+  // The map and owner of all track adapters for the associated peer connection.
+  // When a track is added or removed from this stream, the map provides us with
+  // a reference to the corresponding track adapter, creating a new one if
+  // necessary.
+  scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map_;
 
+  const blink::WebMediaStream web_stream_;
   scoped_refptr<webrtc::MediaStreamInterface> webrtc_media_stream_;
-  std::vector<std::unique_ptr<WebRtcAudioSink>> audio_sinks_;
-  std::vector<std::unique_ptr<MediaStreamVideoWebRtcSink>> video_sinks_;
-
-  DISALLOW_COPY_AND_ASSIGN (WebRtcMediaStreamAdapter);
+  // A map between track IDs and references to track adapters for any tracks
+  // that belong to this stream. Keeping an adapter reference alive ensures the
+  // adapter is not disposed by the |track_adapter_map_|, as is necessary for as
+  // long as the webrtc layer track is in use by the webrtc layer stream.
+  std::map<std::string,
+           std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>>
+      adapter_refs_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebRtcMediaStreamAdapter);
 };
 
 }  // namespace content

content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc

@@ -9,6 +9,7 @@
 #include <memory>
 
 #include "base/message_loop/message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_video_source.h"
@@ -18,6 +19,7 @@
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/processed_local_audio_source.h"
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
@@ -35,10 +37,13 @@ class WebRtcMediaStreamAdapterTest : public ::testing::Test {
   void SetUp() override {
     child_process_.reset(new ChildProcess());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
+    track_adapter_map_ = new WebRtcMediaStreamTrackAdapterMap(
+        dependency_factory_.get(), base::ThreadTaskRunnerHandle::Get());
   }
 
   void TearDown() override {
     adapter_.reset();
+    track_adapter_map_ = nullptr;
     blink::WebHeap::CollectAllGarbageForTesting();
   }
 
@@ -96,7 +101,7 @@ class WebRtcMediaStreamAdapterTest : public ::testing::Test {
                                size_t expected_number_of_audio_tracks,
                                size_t expected_number_of_video_tracks) {
     adapter_.reset(new WebRtcMediaStreamAdapter(
-        blink_stream, dependency_factory_.get()));
+        dependency_factory_.get(), track_adapter_map_, blink_stream));
 
     EXPECT_EQ(expected_number_of_audio_tracks,
               adapter_->webrtc_media_stream()->GetAudioTracks().size());
@@ -118,6 +123,7 @@ class WebRtcMediaStreamAdapterTest : public ::testing::Test {
   base::MessageLoop message_loop_;
   std::unique_ptr<ChildProcess> child_process_;
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
+  scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map_;
   std::unique_ptr<WebRtcMediaStreamAdapter> adapter_;
   MockAudioDeviceFactory mock_audio_device_factory_;
 };

content/renderer/media/webrtc/webrtc_media_stream_track_adapter.cc

@@ -18,7 +18,6 @@ WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     const blink::WebMediaStreamTrack& web_track) {
   DCHECK(main_thread->BelongsToCurrentThread());
-  DCHECK(!web_track.Source().Remote());
   scoped_refptr<WebRtcMediaStreamTrackAdapter> local_track_adapter(
       new WebRtcMediaStreamTrackAdapter(factory, main_thread));
   if (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) {
@@ -71,24 +70,19 @@ void WebRtcMediaStreamTrackAdapter::Dispose() {
   if (!is_initialized_)
     return;
   is_initialized_ = false;
-  if (!web_track_.Source().Remote()) {
-    if (web_track_.Source().GetType() ==
-        blink::WebMediaStreamSource::kTypeAudio) {
+  if (web_track_.Source().GetType() ==
+      blink::WebMediaStreamSource::kTypeAudio) {
+    if (local_track_audio_sink_)
       DisposeLocalAudioTrack();
-    } else {
-      DCHECK_EQ(web_track_.Source().GetType(),
-                blink::WebMediaStreamSource::kTypeVideo);
-      DisposeLocalVideoTrack();
-    }
-  } else {
-    if (web_track_.Source().GetType() ==
-        blink::WebMediaStreamSource::kTypeAudio) {
+    else
       DisposeRemoteAudioTrack();
-    } else {
-      DCHECK_EQ(web_track_.Source().GetType(),
-                blink::WebMediaStreamSource::kTypeVideo);
+  } else {
+    DCHECK_EQ(web_track_.Source().GetType(),
+              blink::WebMediaStreamSource::kTypeVideo);
+    if (local_track_video_sink_)
+      DisposeLocalVideoTrack();
+    else
       DisposeRemoteVideoTrack();
-    }
   }
 }
 
@@ -121,7 +115,6 @@ void WebRtcMediaStreamTrackAdapter::InitializeLocalAudioTrack(
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(!web_track.IsNull());
-  DCHECK(!web_track.Source().Remote());
   DCHECK_EQ(web_track.Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   web_track_ = web_track;
@@ -158,7 +151,6 @@ void WebRtcMediaStreamTrackAdapter::InitializeLocalVideoTrack(
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(!web_track.IsNull());
-  DCHECK(!web_track.Source().Remote());
   DCHECK_EQ(web_track.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   web_track_ = web_track;
@@ -218,12 +210,11 @@ void WebRtcMediaStreamTrackAdapter::
 void WebRtcMediaStreamTrackAdapter::DisposeLocalAudioTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(!web_track_.Source().Remote());
+  DCHECK(local_track_audio_sink_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   MediaStreamAudioTrack* audio_track = MediaStreamAudioTrack::From(web_track_);
   DCHECK(audio_track);
-  DCHECK(local_track_audio_sink_);
   audio_track->RemoveSink(local_track_audio_sink_.get());
   local_track_audio_sink_.reset();
   webrtc_track_ = nullptr;
@@ -233,7 +224,7 @@ void WebRtcMediaStreamTrackAdapter::DisposeLocalAudioTrack() {
 void WebRtcMediaStreamTrackAdapter::DisposeLocalVideoTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(!web_track_.Source().Remote());
+  DCHECK(local_track_video_sink_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   local_track_video_sink_.reset();
@@ -244,7 +235,7 @@ void WebRtcMediaStreamTrackAdapter::DisposeLocalVideoTrack() {
 void WebRtcMediaStreamTrackAdapter::DisposeRemoteAudioTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(web_track_.Source().Remote());
+  DCHECK(remote_audio_track_adapter_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   factory_->GetWebRtcSignalingThread()->PostTask(
@@ -257,7 +248,7 @@ void WebRtcMediaStreamTrackAdapter::DisposeRemoteAudioTrack() {
 void WebRtcMediaStreamTrackAdapter::DisposeRemoteVideoTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(web_track_.Source().Remote());
+  DCHECK(remote_video_track_adapter_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   FinalizeRemoteTrackDisposingOnMainThread();