Change WebRtcMediaStreamTrackAdapter to operate over MediaStreamComponent

... instead WebMediaStreamTrack.

This is part of the effort to reduce the needless use of
public Blink APIs (wrappers) within renderer/modules

BUG=704136
R=guidou@chromium.org

Change-Id: I37023bcd6f1b5fa5f25a475e6a2b19671e8285e9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2247059
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#779507}

third_party/blink/renderer/modules/mediastream/remote_media_stream_track_adapter.cc

@@ -100,7 +100,7 @@ void RemoteAudioTrackAdapter::InitializeWebAudioTrack(
       observed_track().get(), main_thread);
   auto* source_ptr = source.get();
   source_ptr->SetOwner(track()->Source());
-  track()->Source()->SetPlatformSource(std::move(source));
+  track()->Source()->SetPlatformSource(std::move(source));  // Takes ownership.
 
   WebMediaStreamSource::Capabilities capabilities;
   capabilities.device_id = id();

third_party/blink/renderer/modules/peerconnection/rtc_peer_connection_handler.cc

@@ -2314,7 +2314,7 @@ void RTCPeerConnectionHandler::OnAddReceiverPlanB(
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(receiver_state.is_initialized());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnAddReceiverPlanB");
-  auto web_track = receiver_state.track_ref()->web_track();
+  WebMediaStreamTrack web_track = receiver_state.track_ref()->web_track();
   // Update metrics.
   track_metrics_.AddTrack(MediaStreamTrackMetrics::Direction::kReceive,
                           MediaStreamTrackMetricsKind(web_track),

third_party/blink/renderer/modules/peerconnection/rtc_rtp_sender_impl.cc

@@ -500,7 +500,7 @@ webrtc::DtlsTransportInformation RTCRtpSenderImpl::DtlsTransportInformation() {
 
 MediaStreamComponent* RTCRtpSenderImpl::Track() const {
   const auto& track_ref = internal_->state().track_ref();
-  return track_ref ? track_ref->web_track() : blink::WebMediaStreamTrack();
+  return track_ref ? track_ref->web_track() : nullptr;
 }
 
 Vector<String> RTCRtpSenderImpl::StreamIds() const {

third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter.cc

@@ -28,18 +28,17 @@ scoped_refptr<WebRtcMediaStreamTrackAdapter>
 WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
     blink::PeerConnectionDependencyFactory* factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
-    const blink::WebMediaStreamTrack& web_track) {
+    MediaStreamComponent* component) {
   DCHECK(factory);
   DCHECK(main_thread->BelongsToCurrentThread());
-  DCHECK(!web_track.IsNull());
+  DCHECK(component);
   scoped_refptr<WebRtcMediaStreamTrackAdapter> local_track_adapter(
       base::AdoptRef(new WebRtcMediaStreamTrackAdapter(factory, main_thread)));
-  if (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) {
-    local_track_adapter->InitializeLocalAudioTrack(web_track);
+  if (component->Source()->GetType() == MediaStreamSource::kTypeAudio) {
+    local_track_adapter->InitializeLocalAudioTrack(component);
   } else {
-    DCHECK_EQ(web_track.Source().GetType(),
-              blink::WebMediaStreamSource::kTypeVideo);
-    local_track_adapter->InitializeLocalVideoTrack(web_track);
+    DCHECK_EQ(component->Source()->GetType(), MediaStreamSource::kTypeVideo);
+    local_track_adapter->InitializeLocalVideoTrack(component);
   }
   return local_track_adapter;
 }
@@ -108,15 +107,13 @@ void WebRtcMediaStreamTrackAdapter::Dispose() {
     return;
   remote_track_can_complete_initialization_.Reset();
   is_disposed_ = true;
-  if (web_track_.Source().GetType() ==
-      blink::WebMediaStreamSource::kTypeAudio) {
+  if (component_->Source()->GetType() == MediaStreamSource::kTypeAudio) {
     if (local_track_audio_sink_)
       DisposeLocalAudioTrack();
     else
       DisposeRemoteAudioTrack();
   } else {
-    DCHECK_EQ(web_track_.Source().GetType(),
-              blink::WebMediaStreamSource::kTypeVideo);
+    DCHECK_EQ(component_->Source()->GetType(), MediaStreamSource::kTypeVideo);
     if (local_track_video_sink_)
       DisposeLocalVideoTrack();
     else
@@ -137,11 +134,11 @@ void WebRtcMediaStreamTrackAdapter::InitializeOnMainThread() {
   EnsureTrackIsInitialized();
 }
 
-const blink::WebMediaStreamTrack& WebRtcMediaStreamTrackAdapter::web_track() {
+MediaStreamComponent* WebRtcMediaStreamTrackAdapter::track() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   EnsureTrackIsInitialized();
-  DCHECK(!web_track_.IsNull());
-  return web_track_;
+  DCHECK(component_);
+  return component_.Get();
 }
 
 webrtc::MediaStreamTrackInterface*
@@ -152,37 +149,34 @@ WebRtcMediaStreamTrackAdapter::webrtc_track() {
   return webrtc_track_.get();
 }
 
-bool WebRtcMediaStreamTrackAdapter::IsEqual(
-    const blink::WebMediaStreamTrack& web_track) {
+bool WebRtcMediaStreamTrackAdapter::IsEqual(MediaStreamComponent* component) {
   DCHECK(main_thread_->BelongsToCurrentThread());
   EnsureTrackIsInitialized();
-  return web_track_.GetPlatformTrack() == web_track.GetPlatformTrack();
+  return component_->GetPlatformTrack() == component->GetPlatformTrack();
 }
 
 void WebRtcMediaStreamTrackAdapter::InitializeLocalAudioTrack(
-    const blink::WebMediaStreamTrack& web_track) {
+    MediaStreamComponent* component) {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(!web_track.IsNull());
-  DCHECK_EQ(web_track.Source().GetType(),
-            blink::WebMediaStreamSource::kTypeAudio);
+  DCHECK(component);
+  DCHECK_EQ(component->Source()->GetType(), MediaStreamSource::kTypeAudio);
   SendLogMessage(base::StringPrintf("InitializeLocalAudioTrack({id=%s})",
-                                    web_track.Id().Utf8().c_str()));
-  web_track_ = web_track;
-  blink::MediaStreamAudioTrack* native_track =
-      blink::MediaStreamAudioTrack::From(web_track_);
+                                    component->Id().Utf8().c_str()));
+  component_ = component;
+  auto* native_track = MediaStreamAudioTrack::From(component_);
   DCHECK(native_track);
 
   // 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;
-  local_track_audio_sink_.reset(new blink::WebRtcAudioSink(
-      web_track_.Id().Utf8(), source_interface,
-      factory_->GetWebRtcSignalingTaskRunner(), main_thread_));
+  local_track_audio_sink_ = std::make_unique<blink::WebRtcAudioSink>(
+      component_->Id().Utf8(), source_interface,
+      factory_->GetWebRtcSignalingTaskRunner(), main_thread_);
 
   if (auto* media_stream_source = blink::ProcessedLocalAudioSource::From(
-          blink::MediaStreamAudioSource::From(web_track_.Source()))) {
+          blink::MediaStreamAudioSource::From(component_->Source()))) {
     local_track_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
@@ -199,15 +193,14 @@ void WebRtcMediaStreamTrackAdapter::InitializeLocalAudioTrack(
 }
 
 void WebRtcMediaStreamTrackAdapter::InitializeLocalVideoTrack(
-    const blink::WebMediaStreamTrack& web_track) {
+    MediaStreamComponent* component) {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(!web_track.IsNull());
-  DCHECK_EQ(web_track.Source().GetType(),
-            blink::WebMediaStreamSource::kTypeVideo);
-  web_track_ = web_track;
-  local_track_video_sink_.reset(new blink::MediaStreamVideoWebRtcSink(
-      web_track_, factory_, main_thread_));
+  DCHECK(component);
+  DCHECK_EQ(component->Source()->GetType(), MediaStreamSource::kTypeVideo);
+  component_ = component;
+  local_track_video_sink_ = std::make_unique<blink::MediaStreamVideoWebRtcSink>(
+      component_.Get(), factory_, main_thread_);
   webrtc_track_ = local_track_video_sink_->webrtc_video_track();
   DCHECK(webrtc_track_);
   is_initialized_ = true;
@@ -267,10 +260,10 @@ void WebRtcMediaStreamTrackAdapter::
 
   if (remote_audio_track_adapter_) {
     remote_audio_track_adapter_->Initialize();
-    web_track_ = remote_audio_track_adapter_->track();
+    component_ = remote_audio_track_adapter_->track();
   } else {
     remote_video_track_adapter_->Initialize();
-    web_track_ = remote_video_track_adapter_->track();
+    component_ = remote_video_track_adapter_->track();
   }
   is_initialized_ = true;
 }
@@ -289,32 +282,28 @@ void WebRtcMediaStreamTrackAdapter::EnsureTrackIsInitialized() {
 void WebRtcMediaStreamTrackAdapter::DisposeLocalAudioTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(local_track_audio_sink_);
-  DCHECK_EQ(web_track_.Source().GetType(),
-            blink::WebMediaStreamSource::kTypeAudio);
-  blink::MediaStreamAudioTrack* audio_track =
-      blink::MediaStreamAudioTrack::From(web_track_);
+  DCHECK_EQ(component_->Source()->GetType(), MediaStreamSource::kTypeAudio);
+  auto* audio_track = MediaStreamAudioTrack::From(component_);
   DCHECK(audio_track);
   audio_track->RemoveSink(local_track_audio_sink_.get());
   local_track_audio_sink_.reset();
   webrtc_track_ = nullptr;
-  web_track_.Reset();
+  component_ = nullptr;
 }
 
 void WebRtcMediaStreamTrackAdapter::DisposeLocalVideoTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(local_track_video_sink_);
-  DCHECK_EQ(web_track_.Source().GetType(),
-            blink::WebMediaStreamSource::kTypeVideo);
+  DCHECK_EQ(component_->Source()->GetType(), MediaStreamSource::kTypeVideo);
   local_track_video_sink_.reset();
   webrtc_track_ = nullptr;
-  web_track_.Reset();
+  component_ = nullptr;
 }
 
 void WebRtcMediaStreamTrackAdapter::DisposeRemoteAudioTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(remote_audio_track_adapter_);
-  DCHECK_EQ(web_track_.Source().GetType(),
-            blink::WebMediaStreamSource::kTypeAudio);
+  DCHECK_EQ(component_->Source()->GetType(), MediaStreamSource::kTypeAudio);
   PostCrossThreadTask(
       *factory_->GetWebRtcSignalingTaskRunner().get(), FROM_HERE,
       CrossThreadBindOnce(
@@ -326,8 +315,7 @@ void WebRtcMediaStreamTrackAdapter::DisposeRemoteAudioTrack() {
 void WebRtcMediaStreamTrackAdapter::DisposeRemoteVideoTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(remote_video_track_adapter_);
-  DCHECK_EQ(web_track_.Source().GetType(),
-            blink::WebMediaStreamSource::kTypeVideo);
+  DCHECK_EQ(component_->Source()->GetType(), MediaStreamSource::kTypeVideo);
   FinalizeRemoteTrackDisposingOnMainThread();
 }
 
@@ -349,7 +337,7 @@ void WebRtcMediaStreamTrackAdapter::FinalizeRemoteTrackDisposingOnMainThread() {
   remote_audio_track_adapter_ = nullptr;
   remote_video_track_adapter_ = nullptr;
   webrtc_track_ = nullptr;
-  web_track_.Reset();
+  component_ = nullptr;
 }
 
 }  // namespace blink

third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter.h

@@ -9,10 +9,10 @@
 
 #include "base/synchronization/waitable_event.h"
 #include "third_party/blink/public/platform/web_media_stream.h"
-#include "third_party/blink/public/platform/web_media_stream_track.h"
 #include "third_party/blink/renderer/modules/mediastream/remote_media_stream_track_adapter.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/modules/peerconnection/media_stream_video_webrtc_sink.h"
+#include "third_party/blink/renderer/platform/mediastream/media_stream_component.h"
 #include "third_party/blink/renderer/platform/peerconnection/webrtc_audio_sink.h"
 #include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
 #include "third_party/webrtc/api/media_stream_interface.h"
@@ -35,9 +35,9 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapter
   // Invoke on the main thread. The returned adapter is fully initialized, see
   // |is_initialized|. The adapter will keep a reference to the |main_thread|.
   static scoped_refptr<WebRtcMediaStreamTrackAdapter> CreateLocalTrackAdapter(
-      blink::PeerConnectionDependencyFactory* factory,
+      PeerConnectionDependencyFactory* factory,
       const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
-      const blink::WebMediaStreamTrack& web_track);
+      MediaStreamComponent* component);
   // Invoke on the webrtc signaling thread. Initialization finishes on the main
   // thread in a post, meaning returned adapters are ensured to be initialized
   // in posts to the main thread, see |is_initialized|. The adapter will keep
@@ -58,9 +58,9 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapter
   // These methods must be called on the main thread.
   // TODO(hbos): Allow these methods to be called on any thread and make them
   // const. https://crbug.com/756436
-  const blink::WebMediaStreamTrack& web_track();
+  MediaStreamComponent* track();
   webrtc::MediaStreamTrackInterface* webrtc_track();
-  bool IsEqual(const blink::WebMediaStreamTrack& web_track);
+  bool IsEqual(MediaStreamComponent* component);
 
   // For testing.
   blink::WebRtcAudioSink* GetLocalTrackAudioSinkForTesting() {
@@ -88,8 +88,8 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapter
 
  private:
   // Initialization of local tracks occurs on the main thread.
-  void InitializeLocalAudioTrack(const blink::WebMediaStreamTrack& web_track);
-  void InitializeLocalVideoTrack(const blink::WebMediaStreamTrack& web_track);
+  void InitializeLocalAudioTrack(MediaStreamComponent* component);
+  void InitializeLocalVideoTrack(MediaStreamComponent* component);
   // Initialization of remote tracks starts on the webrtc signaling thread and
   // finishes on the main thread.
   void InitializeRemoteAudioTrack(
@@ -121,7 +121,7 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapter
   base::WaitableEvent remote_track_can_complete_initialization_;
   bool is_initialized_;
   bool is_disposed_;
-  blink::WebMediaStreamTrack web_track_;
+  CrossThreadPersistent<MediaStreamComponent> component_;
   scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track_;
   // If the track is local, a sink is added to the local webrtc track that is
   // owned by us.

third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter_map.cc

@@ -42,7 +42,7 @@ WebRtcMediaStreamTrackAdapterMap::AdapterRef::~AdapterRef() {
       DCHECK(adapter->is_initialized());
       if (type_ == Type::kLocal) {
         map_->local_track_adapters_.EraseByPrimary(
-            adapter->web_track().UniqueId());
+            adapter->track()->UniqueId());
       } else {
         map_->remote_track_adapters_.EraseByPrimary(adapter->webrtc_track());
       }
@@ -66,9 +66,10 @@ void WebRtcMediaStreamTrackAdapterMap::AdapterRef::InitializeOnMainThread() {
   adapter_->InitializeOnMainThread();
   if (type_ == WebRtcMediaStreamTrackAdapterMap::AdapterRef::Type::kRemote) {
     base::AutoLock scoped_lock(map_->lock_);
-    if (!map_->remote_track_adapters_.FindBySecondary(web_track().UniqueId())) {
+    if (!map_->remote_track_adapters_.FindBySecondary(
+            web_track()->UniqueId())) {
       map_->remote_track_adapters_.SetSecondaryKey(webrtc_track(),
-                                                   web_track().UniqueId());
+                                                   web_track()->UniqueId());
     }
   }
 }

third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter_map.h

@@ -38,9 +38,7 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapterMap
     std::unique_ptr<AdapterRef> Copy() const;
     bool is_initialized() const { return adapter_->is_initialized(); }
     void InitializeOnMainThread();
-    const blink::WebMediaStreamTrack& web_track() const {
-      return adapter_->web_track();
-    }
+    MediaStreamComponent* web_track() const { return adapter_->track(); }
     webrtc::MediaStreamTrackInterface* webrtc_track() const {
       return adapter_->webrtc_track();
     }

third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter_test.cc

@@ -127,14 +127,14 @@ TEST_F(WebRtcMediaStreamTrackAdapterTest, LocalAudioTrack) {
       blink::WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
           dependency_factory_.get(), main_thread_, CreateLocalAudioTrack());
   EXPECT_TRUE(track_adapter_->is_initialized());
-  EXPECT_TRUE(!track_adapter_->web_track().IsNull());
-  EXPECT_EQ(track_adapter_->web_track().Source().GetType(),
-            blink::WebMediaStreamSource::kTypeAudio);
+  EXPECT_TRUE(track_adapter_->track());
+  EXPECT_EQ(track_adapter_->track()->Source()->GetType(),
+            MediaStreamSource::kTypeAudio);
   EXPECT_TRUE(track_adapter_->webrtc_track());
   EXPECT_EQ(track_adapter_->webrtc_track()->kind(),
             webrtc::MediaStreamTrackInterface::kAudioKind);
   EXPECT_EQ(track_adapter_->webrtc_track()->id().c_str(),
-            track_adapter_->web_track().Id());
+            track_adapter_->track()->Id());
   EXPECT_TRUE(track_adapter_->GetLocalTrackAudioSinkForTesting());
   EXPECT_EQ(
       track_adapter_->GetLocalTrackAudioSinkForTesting()->webrtc_audio_track(),
@@ -147,14 +147,14 @@ TEST_F(WebRtcMediaStreamTrackAdapterTest, DISABLED_LocalVideoTrack) {
       blink::WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
           dependency_factory_.get(), main_thread_, CreateLocalVideoTrack());
   EXPECT_TRUE(track_adapter_->is_initialized());
-  EXPECT_TRUE(!track_adapter_->web_track().IsNull());
-  EXPECT_EQ(track_adapter_->web_track().Source().GetType(),
-            blink::WebMediaStreamSource::kTypeVideo);
+  EXPECT_TRUE(track_adapter_->track());
+  EXPECT_EQ(track_adapter_->track()->Source()->GetType(),
+            MediaStreamSource::kTypeVideo);
   EXPECT_TRUE(track_adapter_->webrtc_track());
   EXPECT_EQ(track_adapter_->webrtc_track()->kind(),
             webrtc::MediaStreamTrackInterface::kVideoKind);
   EXPECT_EQ(track_adapter_->webrtc_track()->id().c_str(),
-            track_adapter_->web_track().Id());
+            track_adapter_->track()->Id());
   EXPECT_TRUE(track_adapter_->GetLocalTrackVideoSinkForTesting());
   EXPECT_EQ(
       track_adapter_->GetLocalTrackVideoSinkForTesting()->webrtc_video_track(),
@@ -173,14 +173,14 @@ TEST_F(WebRtcMediaStreamTrackAdapterTest, RemoteAudioTrack) {
   RunMessageLoopsUntilIdle();
   DCHECK(track_adapter_);
   EXPECT_TRUE(track_adapter_->is_initialized());
-  EXPECT_TRUE(!track_adapter_->web_track().IsNull());
-  EXPECT_EQ(track_adapter_->web_track().Source().GetType(),
-            blink::WebMediaStreamSource::kTypeAudio);
+  EXPECT_TRUE(track_adapter_->track());
+  EXPECT_EQ(track_adapter_->track()->Source()->GetType(),
+            MediaStreamSource::kTypeAudio);
   EXPECT_TRUE(track_adapter_->webrtc_track());
   EXPECT_EQ(track_adapter_->webrtc_track()->kind(),
             webrtc::MediaStreamTrackInterface::kAudioKind);
   EXPECT_EQ(track_adapter_->webrtc_track()->id().c_str(),
-            track_adapter_->web_track().Id());
+            track_adapter_->track()->Id());
   EXPECT_TRUE(track_adapter_->GetRemoteAudioTrackAdapterForTesting());
   EXPECT_TRUE(
       track_adapter_->GetRemoteAudioTrackAdapterForTesting()->initialized());
@@ -198,14 +198,14 @@ TEST_F(WebRtcMediaStreamTrackAdapterTest, RemoteVideoTrack) {
   RunMessageLoopsUntilIdle();
   DCHECK(track_adapter_);
   EXPECT_TRUE(track_adapter_->is_initialized());
-  EXPECT_TRUE(!track_adapter_->web_track().IsNull());
-  EXPECT_EQ(track_adapter_->web_track().Source().GetType(),
-            blink::WebMediaStreamSource::kTypeVideo);
+  EXPECT_TRUE(track_adapter_->track());
+  EXPECT_EQ(track_adapter_->track()->Source()->GetType(),
+            MediaStreamSource::kTypeVideo);
   EXPECT_TRUE(track_adapter_->webrtc_track());
   EXPECT_EQ(track_adapter_->webrtc_track()->kind(),
             webrtc::MediaStreamTrackInterface::kVideoKind);
   EXPECT_EQ(track_adapter_->webrtc_track()->id().c_str(),
-            track_adapter_->web_track().Id());
+            track_adapter_->track()->Id());
   EXPECT_TRUE(track_adapter_->GetRemoteVideoTrackAdapterForTesting());
   EXPECT_TRUE(
       track_adapter_->GetRemoteVideoTrackAdapterForTesting()->initialized());
@@ -227,14 +227,14 @@ TEST_F(WebRtcMediaStreamTrackAdapterTest, RemoteTrackExplicitlyInitialized) {
   // Explicitly initialize before the main thread loop has a chance to run.
   track_adapter_->InitializeOnMainThread();
   EXPECT_TRUE(track_adapter_->is_initialized());
-  EXPECT_TRUE(!track_adapter_->web_track().IsNull());
-  EXPECT_EQ(track_adapter_->web_track().Source().GetType(),
-            blink::WebMediaStreamSource::kTypeAudio);
+  EXPECT_TRUE(track_adapter_->track());
+  EXPECT_EQ(track_adapter_->track()->Source()->GetType(),
+            MediaStreamSource::kTypeAudio);
   EXPECT_TRUE(track_adapter_->webrtc_track());
   EXPECT_EQ(track_adapter_->webrtc_track()->kind(),
             webrtc::MediaStreamTrackInterface::kAudioKind);
   EXPECT_EQ(track_adapter_->webrtc_track()->id().c_str(),
-            track_adapter_->web_track().Id());
+            track_adapter_->track()->Id());
   EXPECT_TRUE(track_adapter_->GetRemoteAudioTrackAdapterForTesting());
   EXPECT_TRUE(
       track_adapter_->GetRemoteAudioTrackAdapterForTesting()->initialized());