Change WebRtcMediaStreamTrackAdapterMap to operate over MediaStreamComponent

... instead of 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: I272f435b314a5697abc74a279110477b99d69b6b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2245046
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#779601}

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

@@ -2314,11 +2314,11 @@ void RTCPeerConnectionHandler::OnAddReceiverPlanB(
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(receiver_state.is_initialized());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnAddReceiverPlanB");
-  WebMediaStreamTrack web_track = receiver_state.track_ref()->web_track();
+  auto* track = receiver_state.track_ref()->track();
   // Update metrics.
   track_metrics_.AddTrack(MediaStreamTrackMetrics::Direction::kReceive,
-                          MediaStreamTrackMetricsKind(web_track),
-                          web_track.Id().Utf8());
+                          MediaStreamTrackMetricsKind(track),
+                          track->Id().Utf8());
   for (const auto& stream_id : receiver_state.stream_ids()) {
     // New remote stream?
     if (!IsRemoteStream(rtp_receivers_, stream_id)) {

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

@@ -318,7 +318,7 @@ RTCRtpReceiverImpl::DtlsTransportInformation() {
 }
 
 MediaStreamComponent* RTCRtpReceiverImpl::Track() const {
-  return internal_->state().track_ref()->web_track();
+  return internal_->state().track_ref()->track();
 }
 
 Vector<String> RTCRtpReceiverImpl::StreamIds() const {

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() : nullptr;
+  return track_ref ? track_ref->track() : nullptr;
 }
 
 Vector<String> RTCRtpSenderImpl::StreamIds() const {

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

@@ -66,10 +66,9 @@ 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(track()->UniqueId())) {
       map_->remote_track_adapters_.SetSecondaryKey(webrtc_track(),
-                                                   web_track()->UniqueId());
+                                                   track()->UniqueId());
     }
   }
 }
@@ -89,10 +88,10 @@ WebRtcMediaStreamTrackAdapterMap::~WebRtcMediaStreamTrackAdapterMap() {
 
 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
 WebRtcMediaStreamTrackAdapterMap::GetLocalTrackAdapter(
-    const blink::WebMediaStreamTrack& web_track) {
+    MediaStreamComponent* component) {
   base::AutoLock scoped_lock(lock_);
   scoped_refptr<blink::WebRtcMediaStreamTrackAdapter>* adapter_ptr =
-      local_track_adapters_.FindByPrimary(web_track.UniqueId());
+      local_track_adapters_.FindByPrimary(component->UniqueId());
   if (!adapter_ptr)
     return nullptr;
   return base::WrapUnique(
@@ -113,12 +112,12 @@ WebRtcMediaStreamTrackAdapterMap::GetLocalTrackAdapter(
 
 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
 WebRtcMediaStreamTrackAdapterMap::GetOrCreateLocalTrackAdapter(
-    const blink::WebMediaStreamTrack& web_track) {
-  DCHECK(!web_track.IsNull());
+    MediaStreamComponent* component) {
+  DCHECK(component);
   DCHECK(main_thread_->BelongsToCurrentThread());
   base::AutoLock scoped_lock(lock_);
   scoped_refptr<blink::WebRtcMediaStreamTrackAdapter>* adapter_ptr =
-      local_track_adapters_.FindByPrimary(web_track.UniqueId());
+      local_track_adapters_.FindByPrimary(component->UniqueId());
   if (adapter_ptr) {
     return base::WrapUnique(
         new AdapterRef(this, AdapterRef::Type::kLocal, *adapter_ptr));
@@ -130,11 +129,11 @@ WebRtcMediaStreamTrackAdapterMap::GetOrCreateLocalTrackAdapter(
     // is blocked waiting for |lock_| we end up in a deadlock.
     base::AutoUnlock scoped_unlock(lock_);
     new_adapter = blink::WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
-        factory_, main_thread_, web_track);
+        factory_, main_thread_, component);
   }
   DCHECK(new_adapter->is_initialized());
-  local_track_adapters_.Insert(web_track.UniqueId(), new_adapter);
-  local_track_adapters_.SetSecondaryKey(web_track.UniqueId(),
+  local_track_adapters_.Insert(component->UniqueId(), new_adapter);
+  local_track_adapters_.SetSecondaryKey(component->UniqueId(),
                                         new_adapter->webrtc_track());
   return base::WrapUnique(
       new AdapterRef(this, AdapterRef::Type::kLocal, new_adapter));
@@ -147,10 +146,10 @@ size_t WebRtcMediaStreamTrackAdapterMap::GetLocalTrackCount() const {
 
 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
 WebRtcMediaStreamTrackAdapterMap::GetRemoteTrackAdapter(
-    const blink::WebMediaStreamTrack& web_track) {
+    MediaStreamComponent* component) {
   base::AutoLock scoped_lock(lock_);
   scoped_refptr<blink::WebRtcMediaStreamTrackAdapter>* adapter_ptr =
-      remote_track_adapters_.FindBySecondary(web_track.UniqueId());
+      remote_track_adapters_.FindBySecondary(component->UniqueId());
   if (!adapter_ptr)
     return nullptr;
   DCHECK((*adapter_ptr)->is_initialized());

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

@@ -5,9 +5,9 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_WEBRTC_MEDIA_STREAM_TRACK_ADAPTER_MAP_H_
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_WEBRTC_MEDIA_STREAM_TRACK_ADAPTER_MAP_H_
 
-#include "third_party/blink/public/platform/web_media_stream_track.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter.h"
+#include "third_party/blink/renderer/platform/mediastream/media_stream_component.h"
 #include "third_party/blink/renderer/platform/peerconnection/two_keys_adapter_map.h"
 #include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
 #include "third_party/webrtc/api/media_stream_interface.h"
@@ -38,7 +38,7 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapterMap
     std::unique_ptr<AdapterRef> Copy() const;
     bool is_initialized() const { return adapter_->is_initialized(); }
     void InitializeOnMainThread();
-    MediaStreamComponent* web_track() const { return adapter_->track(); }
+    MediaStreamComponent* track() const { return adapter_->track(); }
     webrtc::MediaStreamTrackInterface* webrtc_track() const {
       return adapter_->webrtc_track();
     }
@@ -79,7 +79,7 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapterMap
   // The adapter is a associated with a blink and webrtc track, lookup works by
   // either track.
   std::unique_ptr<AdapterRef> GetLocalTrackAdapter(
-      const blink::WebMediaStreamTrack& web_track);
+      MediaStreamComponent* component);
   std::unique_ptr<AdapterRef> GetLocalTrackAdapter(
       webrtc::MediaStreamTrackInterface* webrtc_track);
   // Invoke on the main thread. Gets a new reference to the local track adapter
@@ -87,7 +87,7 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapterMap
   // initialized. When all references are destroyed the adapter is disposed and
   // removed from the map. References must be destroyed on the main thread.
   std::unique_ptr<AdapterRef> GetOrCreateLocalTrackAdapter(
-      const blink::WebMediaStreamTrack& web_track);
+      MediaStreamComponent* component);
   size_t GetLocalTrackCount() const;
 
   // Gets a new reference to the remote track adapter. When all references are
@@ -98,7 +98,7 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapterMap
   // First variety: If an adapter exists it will already be initialized, if one
   // does not exist null is returned.
   std::unique_ptr<AdapterRef> GetRemoteTrackAdapter(
-      const blink::WebMediaStreamTrack& web_track);
+      MediaStreamComponent* component);
   // Second variety: If an adapter exists it may or may not be initialized, see
   // |AdapterRef::is_initialized|. If an adapter does not exist null is
   // returned.
@@ -116,20 +116,20 @@ class MODULES_EXPORT WebRtcMediaStreamTrackAdapterMap
  private:
   friend class WTF::ThreadSafeRefCounted<WebRtcMediaStreamTrackAdapterMap>;
 
-  // "(blink::WebMediaStreamTrack, webrtc::MediaStreamTrackInterface) ->
+  // "(MediaStreamComponent, webrtc::MediaStreamTrackInterface) ->
   // WebRtcMediaStreamTrackAdapter" maps. The primary key is based on the object
   // used to create the adapter. Local tracks are created from
-  // |blink::WebMediaStreamTrack|s, remote tracks are created from
+  // |MediaStreamComponent|s, remote tracks are created from
   // |webrtc::MediaStreamTrackInterface|s.
   // The adapter keeps the |webrtc::MediaStreamTrackInterface| alive with ref
   // counting making it safe to use a raw pointer for key.
   using LocalTrackAdapterMap = blink::TwoKeysAdapterMap<
-      int,  // blink::WebMediaStreamTrack::UniqueId()
+      int,  // MediaStreamComponent::UniqueId()
       webrtc::MediaStreamTrackInterface*,
       scoped_refptr<blink::WebRtcMediaStreamTrackAdapter>>;
   using RemoteTrackAdapterMap = blink::TwoKeysAdapterMap<
       webrtc::MediaStreamTrackInterface*,
-      int,  // blink::WebMediaStreamTrack::UniqueId()
+      int,  // MediaStreamComponent::UniqueId()
       scoped_refptr<blink::WebRtcMediaStreamTrackAdapter>>;
 
   // Invoke on the main thread.

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

@@ -15,12 +15,10 @@
 #include "base/test/test_timeouts.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
-#include "third_party/blink/public/platform/web_media_stream_source.h"
-#include "third_party/blink/public/platform/web_media_stream_track.h"
-#include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/web/web_heap.h"
 #include "third_party/blink/renderer/modules/peerconnection/mock_peer_connection_dependency_factory.h"
 #include "third_party/blink/renderer/platform/mediastream/media_stream_audio_source.h"
+#include "third_party/blink/renderer/platform/mediastream/media_stream_component.h"
 #include "third_party/blink/renderer/platform/testing/io_task_runner_testing_platform_support.h"
 
 namespace blink {
@@ -40,21 +38,20 @@ class WebRtcMediaStreamTrackAdapterMapTest : public ::testing::Test {
     return dependency_factory_->GetWebRtcSignalingTaskRunner();
   }
 
-  blink::WebMediaStreamTrack CreateLocalTrack(const std::string& id) {
-    blink::WebMediaStreamSource web_source;
-    web_source.Initialize(
-        blink::WebString::FromUTF8(id), blink::WebMediaStreamSource::kTypeAudio,
-        blink::WebString::FromUTF8("local_audio_track"), false);
-    blink::MediaStreamAudioSource* audio_source =
-        new blink::MediaStreamAudioSource(
-            blink::scheduler::GetSingleThreadTaskRunnerForTesting(), true);
+  MediaStreamComponent* CreateLocalTrack(const std::string& id) {
+    auto* source = MakeGarbageCollected<MediaStreamSource>(
+        String::FromUTF8(id), MediaStreamSource::kTypeAudio,
+        String::FromUTF8("local_audio_track"), false);
+    MediaStreamAudioSource* audio_source = new MediaStreamAudioSource(
+        scheduler::GetSingleThreadTaskRunnerForTesting(), true);
     // Takes ownership of |audio_source|.
-    web_source.SetPlatformSource(base::WrapUnique(audio_source));
+    audio_source->SetOwner(source);
+    source->SetPlatformSource(base::WrapUnique(audio_source));
 
-    blink::WebMediaStreamTrack web_track;
-    web_track.Initialize(web_source.Id(), web_source);
-    audio_source->ConnectToTrack(web_track);
-    return web_track;
+    auto* component =
+        MakeGarbageCollected<MediaStreamComponent>(source->Id(), source);
+    audio_source->ConnectToTrack(component);
+    return component;
   }
 
   std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
@@ -120,17 +117,17 @@ class WebRtcMediaStreamTrackAdapterMapTest : public ::testing::Test {
 };
 
 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndRemoveLocalTrackAdapter) {
-  blink::WebMediaStreamTrack web_track = CreateLocalTrack("local_track");
+  MediaStreamComponent* track = CreateLocalTrack("local_track");
   std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
-      adapter_ref = map_->GetOrCreateLocalTrackAdapter(web_track);
+      adapter_ref = map_->GetOrCreateLocalTrackAdapter(track);
   EXPECT_TRUE(adapter_ref->is_initialized());
   EXPECT_EQ(adapter_ref->GetAdapterForTesting(),
-            map_->GetLocalTrackAdapter(web_track)->GetAdapterForTesting());
+            map_->GetLocalTrackAdapter(track)->GetAdapterForTesting());
   EXPECT_EQ(1u, map_->GetLocalTrackCount());
 
   // "GetOrCreate" for already existing track.
   std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
-      adapter_ref2 = map_->GetOrCreateLocalTrackAdapter(web_track);
+      adapter_ref2 = map_->GetOrCreateLocalTrackAdapter(track);
   EXPECT_EQ(adapter_ref->GetAdapterForTesting(),
             adapter_ref2->GetAdapterForTesting());
   EXPECT_EQ(1u, map_->GetLocalTrackCount());
@@ -143,7 +140,7 @@ TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndRemoveLocalTrackAdapter) {
   // dispose it.
   adapter_ref.reset();
   EXPECT_EQ(0u, map_->GetLocalTrackCount());
-  EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(web_track));
+  EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(track));
   // Allow the disposing of track to occur.
   RunMessageLoopsUntilIdle();
 }
@@ -207,13 +204,12 @@ TEST_F(WebRtcMediaStreamTrackAdapterMapTest,
   // Local and remote tracks should be able to use the same id without conflict.
   const char* id = "id";
 
-  blink::WebMediaStreamTrack local_web_track = CreateLocalTrack(id);
+  MediaStreamComponent* local_track = CreateLocalTrack(id);
   std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
-      local_adapter = map_->GetOrCreateLocalTrackAdapter(local_web_track);
+      local_adapter = map_->GetOrCreateLocalTrackAdapter(local_track);
   EXPECT_TRUE(local_adapter->is_initialized());
-  EXPECT_EQ(
-      local_adapter->GetAdapterForTesting(),
-      map_->GetLocalTrackAdapter(local_web_track)->GetAdapterForTesting());
+  EXPECT_EQ(local_adapter->GetAdapterForTesting(),
+            map_->GetLocalTrackAdapter(local_track)->GetAdapterForTesting());
   EXPECT_EQ(1u, map_->GetLocalTrackCount());
 
   scoped_refptr<blink::MockWebRtcAudioTrack> remote_webrtc_track =
@@ -233,15 +229,15 @@ TEST_F(WebRtcMediaStreamTrackAdapterMapTest,
   remote_adapter.reset();
   EXPECT_EQ(0u, map_->GetLocalTrackCount());
   EXPECT_EQ(0u, map_->GetRemoteTrackCount());
-  EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(local_web_track));
+  EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(local_track));
   EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter(remote_webrtc_track.get()));
   // Allow the disposing of tracks to occur.
   RunMessageLoopsUntilIdle();
 }
 
 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, GetMissingLocalTrackAdapter) {
-  blink::WebMediaStreamTrack local_web_track = CreateLocalTrack("missing");
-  EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(local_web_track));
+  MediaStreamComponent* local_track = CreateLocalTrack("missing");
+  EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(local_track));
 }
 
 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, GetMissingRemoteTrackAdapter) {