Content-layer transceiver added.

WebRTCRtpTransceiver added for surfacing transceivers in future CLs.
Implementation added in content and test coverage added.

The content::RTCRtpTransceiver is implemented with a similar design as
content::RTCRtp[Sender/Receiver]:
- It has an "internal" ref counted class, allowing multiple
  WebRTCRtpTransceivers to represent the same webrtc layer transceiver.
- The "state" is in a separate class, allowing surfacing transceiver
  state information separately from implementation, and use of
  TransceiverStateSurfacer.

Stop(), blink-layer RTCRtpTransceiver and Unified Plan usage will be
added in follow-up CLs.

This CL also removes all dependencies on
webrtc_media_stream_adapter_map.[h/cc] unblocking its deletion.

Bug: 777617
Change-Id: Icbc4a6b53ef57df8da6bc10e9e432644368ba5dd
Reviewed-on: https://chromium-review.googlesource.com/1131475Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Commit-Queue: Henrik Boström <hbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#574945}

content/renderer/media/webrtc/mock_peer_connection_impl.cc

@@ -12,6 +12,7 @@
 #include "base/stl_util.h"
 #include "content/renderer/media/webrtc/mock_data_channel_impl.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
+#include "content/renderer/media/webrtc/webrtc_util.h"
 #include "third_party/webrtc/api/rtpreceiverinterface.h"
 #include "third_party/webrtc/rtc_base/refcountedobject.h"
 
@@ -209,10 +210,18 @@ std::vector<webrtc::RtpSource> FakeRtpReceiver::GetSources() const {
 FakeRtpTransceiver::FakeRtpTransceiver(
     cricket::MediaType media_type,
     rtc::scoped_refptr<webrtc::RtpSenderInterface> sender,
-    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+    base::Optional<std::string> mid,
+    bool stopped,
+    webrtc::RtpTransceiverDirection direction,
+    base::Optional<webrtc::RtpTransceiverDirection> current_direction)
     : media_type_(media_type),
       sender_(std::move(sender)),
-      receiver_(std::move(receiver)) {}
+      receiver_(std::move(receiver)),
+      mid_(ToAbslOptional(mid)),
+      stopped_(stopped),
+      direction_(direction),
+      current_direction_(ToAbslOptional(current_direction)) {}
 
 FakeRtpTransceiver::~FakeRtpTransceiver() {}
 
@@ -221,7 +230,7 @@ cricket::MediaType FakeRtpTransceiver::media_type() const {
 }
 
 absl::optional<std::string> FakeRtpTransceiver::mid() const {
-  return absl::nullopt;
+  return mid_;
 }
 
 rtc::scoped_refptr<webrtc::RtpSenderInterface> FakeRtpTransceiver::sender()
@@ -235,11 +244,11 @@ rtc::scoped_refptr<webrtc::RtpReceiverInterface> FakeRtpTransceiver::receiver()
 }
 
 bool FakeRtpTransceiver::stopped() const {
-  return false;
+  return stopped_;
 }
 
 webrtc::RtpTransceiverDirection FakeRtpTransceiver::direction() const {
-  return webrtc::RtpTransceiverDirection::kSendRecv;
+  return direction_;
 }
 
 void FakeRtpTransceiver::SetDirection(
@@ -249,7 +258,7 @@ void FakeRtpTransceiver::SetDirection(
 
 absl::optional<webrtc::RtpTransceiverDirection>
 FakeRtpTransceiver::current_direction() const {
-  return absl::nullopt;
+  return current_direction_;
 }
 
 void FakeRtpTransceiver::Stop() {

content/renderer/media/webrtc/mock_peer_connection_impl.h

@@ -11,6 +11,7 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/optional.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/api/stats/rtcstatsreport.h"
@@ -67,11 +68,18 @@ class FakeRtpReceiver : public webrtc::RtpReceiverInterface {
 
 class FakeRtpTransceiver : public webrtc::RtpTransceiverInterface {
  public:
-  FakeRtpTransceiver(cricket::MediaType media_type,
-                     rtc::scoped_refptr<webrtc::RtpSenderInterface> sender,
-                     rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
+  FakeRtpTransceiver(
+      cricket::MediaType media_type,
+      rtc::scoped_refptr<webrtc::RtpSenderInterface> sender,
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+      base::Optional<std::string> mid,
+      bool stopped,
+      webrtc::RtpTransceiverDirection direction,
+      base::Optional<webrtc::RtpTransceiverDirection> current_direction);
   ~FakeRtpTransceiver() override;
 
+  FakeRtpTransceiver& operator=(const FakeRtpTransceiver& other) = default;
+
   cricket::MediaType media_type() const override;
   absl::optional<std::string> mid() const override;
   rtc::scoped_refptr<webrtc::RtpSenderInterface> sender() const override;
@@ -89,6 +97,10 @@ class FakeRtpTransceiver : public webrtc::RtpTransceiverInterface {
   cricket::MediaType media_type_;
   rtc::scoped_refptr<webrtc::RtpSenderInterface> sender_;
   rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver_;
+  absl::optional<std::string> mid_;
+  bool stopped_;
+  webrtc::RtpTransceiverDirection direction_;
+  absl::optional<webrtc::RtpTransceiverDirection> current_direction_;
 };
 
 // TODO(hbos): The use of fakes and mocks is the wrong approach for testing of

content/renderer/media/webrtc/rtc_peer_connection_handler.cc

@@ -1245,9 +1245,6 @@ RTCPeerConnectionHandler::RTCPeerConnectionHandler(
       track_adapter_map_(
           new WebRtcMediaStreamTrackAdapterMap(dependency_factory_,
                                                task_runner)),
-      stream_adapter_map_(new WebRtcMediaStreamAdapterMap(dependency_factory_,
-                                                          task_runner,
-                                                          track_adapter_map_)),
       task_runner_(std::move(task_runner)),
       weak_factory_(this) {
   CHECK(client_);
@@ -1773,7 +1770,7 @@ std::unique_ptr<blink::WebRTCRtpSender> RTCPeerConnectionHandler::AddTrack(
                               std::move(stream_ids));
   sender_state.Initialize();
   rtp_senders_.push_back(std::make_unique<RTCRtpSender>(
-      native_peer_connection_, stream_adapter_map_, std::move(sender_state)));
+      native_peer_connection_, track_adapter_map_, std::move(sender_state)));
   if (peer_connection_tracker_) {
     peer_connection_tracker_->TrackAddTransceiver(
         this, PeerConnectionTracker::TransceiverUpdatedReason::kAddTrack,

content/renderer/media/webrtc/rtc_peer_connection_handler.h

@@ -22,7 +22,6 @@
 #include "content/renderer/media/webrtc/media_stream_track_metrics.h"
 #include "content/renderer/media/webrtc/rtc_rtp_receiver.h"
 #include "content/renderer/media/webrtc/rtc_rtp_sender.h"
-#include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "ipc/ipc_platform_file.h"
 #include "third_party/blink/public/platform/web_media_stream_source.h"
@@ -273,14 +272,6 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   // needs to reference it, and automatically disposed when there are no longer
   // any components referencing it.
   scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map_;
-  // Map and owners of stream adapters. Every stream 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::WebMediaStream|s
-  // and |webrtc::MediaStreamInterface|s. Stream adapters are created on the fly
-  // when a component (such as a sender or receiver) needs to reference it, and
-  // automatically disposed when there are no longer any components referencing
-  // it.
-  scoped_refptr<WebRtcMediaStreamAdapterMap> stream_adapter_map_;
   // Content layer correspondents of |webrtc::RtpSenderInterface|.
   std::vector<std::unique_ptr<RTCRtpSender>> rtp_senders_;
   // Maps |RTCRtpReceiver::getId|s of |webrtc::RtpReceiverInterface|s to the

content/renderer/media/webrtc/rtc_rtp_receiver.cc

@@ -123,7 +123,7 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
     return state_;
   }
 
-  void SetState(RtpReceiverState state) {
+  void set_state(RtpReceiverState state) {
     DCHECK(main_task_runner_->BelongsToCurrentThread());
     DCHECK(state.main_task_runner() == main_task_runner_);
     DCHECK(state.signaling_task_runner() == signaling_task_runner_);
@@ -170,7 +170,7 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
   const scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection_;
   // Task runners and webrtc receiver: Same information as stored in
   // |state_| but const and safe to touch on the signaling thread to
-  // avoid race with SetState().
+  // avoid race with set_state().
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner_;
   const scoped_refptr<webrtc::RtpReceiverInterface> webrtc_receiver_;
@@ -226,8 +226,8 @@ const RtpReceiverState& RTCRtpReceiver::state() const {
   return internal_->state();
 }
 
-void RTCRtpReceiver::SetState(RtpReceiverState state) {
-  internal_->SetState(std::move(state));
+void RTCRtpReceiver::set_state(RtpReceiverState state) {
+  internal_->set_state(std::move(state));
 }
 
 uintptr_t RTCRtpReceiver::Id() const {

content/renderer/media/webrtc/rtc_rtp_receiver.h

@@ -9,7 +9,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "content/common/content_export.h"
-#include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/blink/public/platform/web_media_stream.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
@@ -112,7 +111,7 @@ class CONTENT_EXPORT RTCRtpReceiver : public blink::WebRTCRtpReceiver {
   std::unique_ptr<RTCRtpReceiver> ShallowCopy() const;
 
   const RtpReceiverState& state() const;
-  void SetState(RtpReceiverState state);
+  void set_state(RtpReceiverState state);
 
   uintptr_t Id() const override;
   const blink::WebMediaStreamTrack& Track() const override;

content/renderer/media/webrtc/rtc_rtp_receiver_unittest.cc

@@ -16,7 +16,6 @@
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_impl.h"
 #include "content/renderer/media/webrtc/test/webrtc_stats_report_obtainer.h"
-#include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
@@ -34,10 +33,8 @@ class RTCRtpReceiverTest : public ::testing::Test {
   void SetUp() override {
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     main_thread_ = blink::scheduler::GetSingleThreadTaskRunnerForTesting();
-    stream_map_ = new WebRtcMediaStreamAdapterMap(
-        dependency_factory_.get(), main_thread_,
-        new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
-                                             main_thread_));
+    track_map_ = new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
+                                                      main_thread_);
     peer_connection_ = new rtc::RefCountedObject<MockPeerConnectionImpl>(
         dependency_factory_.get(), nullptr);
   }
@@ -96,9 +93,7 @@ class RTCRtpReceiverTest : public ::testing::Test {
       base::RunLoop* run_loop) {
     mock_webrtc_receiver_ =
         new rtc::RefCountedObject<webrtc::MockRtpReceiver>();
-    *track_ref =
-        stream_map_->track_adapter_map()->GetOrCreateRemoteTrackAdapter(
-            webrtc_track);
+    *track_ref = track_map_->GetOrCreateRemoteTrackAdapter(webrtc_track);
     run_loop->Quit();
   }
 
@@ -109,7 +104,7 @@ class RTCRtpReceiverTest : public ::testing::Test {
 
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
-  scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map_;
+  scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map_;
   rtc::scoped_refptr<MockPeerConnectionImpl> peer_connection_;
   rtc::scoped_refptr<webrtc::MockRtpReceiver> mock_webrtc_receiver_;
   std::unique_ptr<RTCRtpReceiver> receiver_;

content/renderer/media/webrtc/rtc_rtp_sender.cc

@@ -137,15 +137,15 @@ class RTCRtpSender::RTCRtpSenderInternal
  public:
   RTCRtpSenderInternal(
       scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
-      scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map,
+      scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map,
       RtpSenderState state)
       : native_peer_connection_(std::move(native_peer_connection)),
-        stream_map_(std::move(stream_map)),
+        track_map_(std::move(track_map)),
         main_task_runner_(state.main_task_runner()),
         signaling_task_runner_(state.signaling_task_runner()),
         webrtc_sender_(state.webrtc_sender()),
         state_(std::move(state)) {
-    DCHECK(stream_map_);
+    DCHECK(track_map_);
     DCHECK(state_.is_initialized());
   }
 
@@ -169,9 +169,7 @@ class RTCRtpSender::RTCRtpSenderInternal
     std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> track_ref;
     webrtc::MediaStreamTrackInterface* webrtc_track = nullptr;
     if (!with_track.IsNull()) {
-      track_ref =
-          stream_map_->track_adapter_map()->GetOrCreateLocalTrackAdapter(
-              with_track);
+      track_ref = track_map_->GetOrCreateLocalTrackAdapter(with_track);
       webrtc_track = track_ref->webrtc_track();
     }
     signaling_task_runner_->PostTask(
@@ -312,7 +310,7 @@ class RTCRtpSender::RTCRtpSenderInternal
   }
 
   const scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection_;
-  const scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map_;
+  const scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map_;
   // Task runners and webrtc sender: Same information as stored in
   // |state_| but const and safe to touch on the signaling thread to
   // avoid race with set_state().
@@ -348,10 +346,10 @@ uintptr_t RTCRtpSender::getId(const webrtc::RtpSenderInterface* webrtc_sender) {
 
 RTCRtpSender::RTCRtpSender(
     scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
-    scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map,
+    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map,
     RtpSenderState state)
     : internal_(new RTCRtpSenderInternal(std::move(native_peer_connection),
-                                         std::move(stream_map),
+                                         std::move(track_map),
                                          std::move(state))) {}
 
 RTCRtpSender::RTCRtpSender(const RTCRtpSender& other)

content/renderer/media/webrtc/rtc_rtp_sender.h

@@ -11,7 +11,6 @@
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "content/common/content_export.h"
-#include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_sender.h"
@@ -110,7 +109,7 @@ class CONTENT_EXPORT RTCRtpSender : public blink::WebRTCRtpSender {
 
   RTCRtpSender(
       scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
-      scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map,
+      scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map,
       RtpSenderState state);
   RTCRtpSender(const RTCRtpSender& other);
   ~RTCRtpSender() override;

content/renderer/media/webrtc/rtc_rtp_sender_unittest.cc

@@ -16,7 +16,6 @@
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_impl.h"
 #include "content/renderer/media/webrtc/test/webrtc_stats_report_obtainer.h"
-#include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
@@ -40,10 +39,8 @@ class RTCRtpSenderTest : public ::testing::Test {
   void SetUp() override {
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     main_thread_ = blink::scheduler::GetSingleThreadTaskRunnerForTesting();
-    stream_map_ = new WebRtcMediaStreamAdapterMap(
-        dependency_factory_.get(), main_thread_,
-        new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
-                                             main_thread_));
+    track_map_ = new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
+                                                      main_thread_);
     peer_connection_ = new rtc::RefCountedObject<MockPeerConnectionImpl>(
         dependency_factory_.get(), nullptr);
     mock_webrtc_sender_ = new rtc::RefCountedObject<webrtc::MockRtpSender>();
@@ -86,9 +83,7 @@ class RTCRtpSenderTest : public ::testing::Test {
       blink::WebMediaStreamTrack web_track) {
     std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> track_ref;
     if (!web_track.IsNull()) {
-      track_ref =
-          stream_map_->track_adapter_map()->GetOrCreateLocalTrackAdapter(
-              web_track);
+      track_ref = track_map_->GetOrCreateLocalTrackAdapter(web_track);
       DCHECK(track_ref->is_initialized());
     }
     RtpSenderState sender_state(main_thread_,
@@ -96,7 +91,7 @@ class RTCRtpSenderTest : public ::testing::Test {
                                 mock_webrtc_sender_.get(), std::move(track_ref),
                                 std::vector<std::string>());
     sender_state.Initialize();
-    return std::make_unique<RTCRtpSender>(peer_connection_.get(), stream_map_,
+    return std::make_unique<RTCRtpSender>(peer_connection_.get(), track_map_,
                                           std::move(sender_state));
   }
 
@@ -148,7 +143,7 @@ class RTCRtpSenderTest : public ::testing::Test {
 
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
-  scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map_;
+  scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map_;
   rtc::scoped_refptr<MockPeerConnectionImpl> peer_connection_;
   rtc::scoped_refptr<webrtc::MockRtpSender> mock_webrtc_sender_;
   std::unique_ptr<RTCRtpSender> sender_;

content/renderer/media/webrtc/rtc_rtp_transceiver.cc

@@ -156,4 +156,199 @@ RtpTransceiverState::current_direction() const {
   return current_direction_;
 }
 
+class RTCRtpTransceiver::RTCRtpTransceiverInternal
+    : public base::RefCountedThreadSafe<
+          RTCRtpTransceiver::RTCRtpTransceiverInternal,
+          RTCRtpTransceiver::RTCRtpTransceiverInternalTraits> {
+ public:
+  RTCRtpTransceiverInternal(
+      scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
+      scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map,
+      RtpTransceiverState state)
+      : main_task_runner_(state.main_task_runner()),
+        signaling_task_runner_(state.signaling_task_runner()),
+        webrtc_transceiver_(state.webrtc_transceiver()),
+        state_(std::move(state)) {
+    sender_ = std::make_unique<RTCRtpSender>(native_peer_connection, track_map,
+                                             state_.MoveSenderState());
+    receiver_ = std::make_unique<RTCRtpReceiver>(native_peer_connection,
+                                                 state_.MoveReceiverState());
+  }
+
+  const RtpTransceiverState& state() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return state_;
+  }
+
+  void set_state(RtpTransceiverState state) {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    DCHECK_EQ(state.main_task_runner(), main_task_runner_);
+    DCHECK_EQ(state.signaling_task_runner(), signaling_task_runner_);
+    DCHECK(state.webrtc_transceiver() == webrtc_transceiver_);
+    DCHECK(state.is_initialized());
+    state_ = std::move(state);
+    sender_->set_state(state_.MoveSenderState());
+    receiver_->set_state(state_.MoveReceiverState());
+  }
+
+  RTCRtpSender* content_sender() {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return sender_.get();
+  }
+
+  RTCRtpReceiver* content_receiver() {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return receiver_.get();
+  }
+
+  blink::WebString Mid() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return state_.mid() ? blink::WebString::FromUTF8(*state_.mid())
+                        : blink::WebString();  // IsNull()
+  }
+
+  std::unique_ptr<blink::WebRTCRtpSender> Sender() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return sender_->ShallowCopy();
+  }
+
+  std::unique_ptr<blink::WebRTCRtpReceiver> Receiver() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return receiver_->ShallowCopy();
+  }
+
+  bool Stopped() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return state_.stopped();
+  }
+
+  webrtc::RtpTransceiverDirection Direction() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return state_.direction();
+  }
+
+  base::Optional<webrtc::RtpTransceiverDirection> CurrentDirection() const {
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+    return state_.current_direction();
+  }
+
+  // TODO(hbos): Implement. https://crbug.com/777617
+  void Stop() { NOTREACHED() << "Not implemented."; }
+
+ private:
+  friend struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits;
+
+  ~RTCRtpTransceiverInternal() {
+    // Ensured by destructor traits.
+    DCHECK(main_task_runner_->BelongsToCurrentThread());
+  }
+
+  // Task runners and webrtc transceiver: Same information as stored in |state_|
+  // but const and safe to touch on the signaling thread to avoid race with
+  // set_state().
+  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  const scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner_;
+  const scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver_;
+  RtpTransceiverState state_;
+  std::unique_ptr<RTCRtpSender> sender_;
+  std::unique_ptr<RTCRtpReceiver> receiver_;
+};
+
+struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits {
+ private:
+  friend class base::RefCountedThreadSafe<RTCRtpTransceiverInternal,
+                                          RTCRtpTransceiverInternalTraits>;
+
+  static void Destruct(const RTCRtpTransceiverInternal* transceiver) {
+    // RTCRtpTransceiverInternal owns AdapterRefs which have to be destroyed on
+    // the main thread, this ensures delete always happens there.
+    if (!transceiver->main_task_runner_->BelongsToCurrentThread()) {
+      transceiver->main_task_runner_->PostTask(
+          FROM_HERE,
+          base::BindOnce(
+              &RTCRtpTransceiver::RTCRtpTransceiverInternalTraits::Destruct,
+              base::Unretained(transceiver)));
+      return;
+    }
+    delete transceiver;
+  }
+};
+
+uintptr_t RTCRtpTransceiver::GetId(
+    const webrtc::RtpTransceiverInterface* webrtc_transceiver) {
+  return reinterpret_cast<uintptr_t>(webrtc_transceiver);
+}
+
+RTCRtpTransceiver::RTCRtpTransceiver(
+    scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
+    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map,
+    RtpTransceiverState transceiver_state)
+    : internal_(new RTCRtpTransceiverInternal(std::move(native_peer_connection),
+                                              std::move(track_map),
+                                              std::move(transceiver_state))) {}
+
+RTCRtpTransceiver::RTCRtpTransceiver(const RTCRtpTransceiver& other)
+    : internal_(other.internal_) {}
+
+RTCRtpTransceiver::~RTCRtpTransceiver() {}
+
+RTCRtpTransceiver& RTCRtpTransceiver::operator=(
+    const RTCRtpTransceiver& other) {
+  internal_ = other.internal_;
+  return *this;
+}
+
+std::unique_ptr<RTCRtpTransceiver> RTCRtpTransceiver::ShallowCopy() const {
+  return std::make_unique<RTCRtpTransceiver>(*this);
+}
+
+const RtpTransceiverState& RTCRtpTransceiver::state() const {
+  return internal_->state();
+}
+
+RTCRtpSender* RTCRtpTransceiver::content_sender() {
+  return internal_->content_sender();
+}
+
+RTCRtpReceiver* RTCRtpTransceiver::content_receiver() {
+  return internal_->content_receiver();
+}
+
+void RTCRtpTransceiver::set_state(RtpTransceiverState transceiver_state) {
+  internal_->set_state(std::move(transceiver_state));
+}
+
+uintptr_t RTCRtpTransceiver::Id() const {
+  return GetId(internal_->state().webrtc_transceiver().get());
+}
+
+blink::WebString RTCRtpTransceiver::Mid() const {
+  return internal_->Mid();
+}
+
+std::unique_ptr<blink::WebRTCRtpSender> RTCRtpTransceiver::Sender() const {
+  return internal_->Sender();
+}
+
+std::unique_ptr<blink::WebRTCRtpReceiver> RTCRtpTransceiver::Receiver() const {
+  return internal_->Receiver();
+}
+
+bool RTCRtpTransceiver::Stopped() const {
+  return internal_->Stopped();
+}
+
+webrtc::RtpTransceiverDirection RTCRtpTransceiver::Direction() const {
+  return internal_->Direction();
+}
+
+base::Optional<webrtc::RtpTransceiverDirection>
+RTCRtpTransceiver::CurrentDirection() const {
+  return internal_->CurrentDirection();
+}
+
+void RTCRtpTransceiver::Stop() {
+  internal_->Stop();
+}
+
 }  // namespace content

content/renderer/media/webrtc/rtc_rtp_transceiver.h

@@ -10,6 +10,8 @@
 #include "base/single_thread_task_runner.h"
 #include "content/renderer/media/webrtc/rtc_rtp_receiver.h"
 #include "content/renderer/media/webrtc/rtc_rtp_sender.h"
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
+#include "third_party/blink/public/platform/web_rtc_rtp_transceiver.h"
 #include "third_party/webrtc/api/rtptransceiverinterface.h"
 
 namespace content {
@@ -100,6 +102,51 @@ class CONTENT_EXPORT RtpTransceiverState {
   base::Optional<webrtc::RtpTransceiverDirection> current_direction_;
 };
 
+// Used to surface |webrtc::RtpTransceiverInterface| to blink. Multiple
+// |RTCRtpTransceiver|s could reference the same webrtc transceiver; |id| is
+// unique per webrtc transceiver.
+// Its methods are accessed on the main thread, internally also performs
+// operations on the signaling thread.
+// TODO(hbos): [Onion Soup] Remove the content layer versions of this class and
+// rely on webrtc directly from blink. Requires coordination with senders and
+// receivers. https://crbug.com/787254
+class CONTENT_EXPORT RTCRtpTransceiver : public blink::WebRTCRtpTransceiver {
+ public:
+  static uintptr_t GetId(
+      const webrtc::RtpTransceiverInterface* webrtc_transceiver);
+
+  RTCRtpTransceiver(
+      scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
+      scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_map,
+      RtpTransceiverState state);
+  RTCRtpTransceiver(const RTCRtpTransceiver& other);
+  ~RTCRtpTransceiver() override;
+
+  RTCRtpTransceiver& operator=(const RTCRtpTransceiver& other);
+  std::unique_ptr<RTCRtpTransceiver> ShallowCopy() const;
+
+  const RtpTransceiverState& state() const;
+  void set_state(RtpTransceiverState state);
+  RTCRtpSender* content_sender();
+  RTCRtpReceiver* content_receiver();
+
+  uintptr_t Id() const override;
+  blink::WebString Mid() const override;
+  std::unique_ptr<blink::WebRTCRtpSender> Sender() const override;
+  std::unique_ptr<blink::WebRTCRtpReceiver> Receiver() const override;
+  bool Stopped() const override;
+  webrtc::RtpTransceiverDirection Direction() const override;
+  base::Optional<webrtc::RtpTransceiverDirection> CurrentDirection()
+      const override;
+  void Stop() override;
+
+ private:
+  class RTCRtpTransceiverInternal;
+  struct RTCRtpTransceiverInternalTraits;
+
+  scoped_refptr<RTCRtpTransceiverInternal> internal_;
+};
+
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_TRANSCEIVER_H_

content/renderer/media/webrtc/transceiver_state_surfacer_unittest.cc

@@ -64,7 +64,8 @@ class TransceiverStateSurfacerTest : public ::testing::Test {
             ? cricket::MEDIA_TYPE_AUDIO
             : cricket::MEDIA_TYPE_VIDEO,
         CreateWebRtcSender(local_track, local_stream_id),
-        CreateWebRtcReceiver(remote_track_id, remote_stream_id));
+        CreateWebRtcReceiver(remote_track_id, remote_stream_id), base::nullopt,
+        false, webrtc::RtpTransceiverDirection::kSendRecv, base::nullopt);
   }
 
   rtc::scoped_refptr<webrtc::RtpSenderInterface> CreateWebRtcSender(

content/renderer/media/webrtc/webrtc_set_remote_description_observer_unittest.cc

@@ -16,7 +16,6 @@
 #include "content/child/child_process.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_impl.h"
-#include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
@@ -66,15 +65,13 @@ class WebRtcSetRemoteDescriptionObserverHandlerTest : public ::testing::Test {
             new cricket::FakeMediaEngine())));
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     main_thread_ = blink::scheduler::GetSingleThreadTaskRunnerForTesting();
-    scoped_refptr<WebRtcMediaStreamAdapterMap> map =
-        new WebRtcMediaStreamAdapterMap(
-            dependency_factory_.get(), main_thread_,
-            new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
-                                                 main_thread_));
+    scoped_refptr<WebRtcMediaStreamTrackAdapterMap> map =
+        new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
+                                             main_thread_);
     observer_ = new WebRtcSetRemoteDescriptionObserverForTest();
     observer_handler_ = WebRtcSetRemoteDescriptionObserverHandler::Create(
-        main_thread_, dependency_factory_->GetWebRtcSignalingThread(), pc_,
-        map->track_adapter_map(), observer_);
+        main_thread_, dependency_factory_->GetWebRtcSignalingThread(), pc_, map,
+        observer_);
   }
 
   void TearDown() override { blink::WebHeap::CollectAllGarbageForTesting(); }

content/renderer/media/webrtc/webrtc_util.h

@@ -15,6 +15,12 @@ base::Optional<typename OptionalT::value_type> ToBaseOptional(
   return optional ? base::make_optional(*optional) : base::nullopt;
 }
 
+template <typename OptionalT>
+absl::optional<typename OptionalT::value_type> ToAbslOptional(
+    const OptionalT& optional) {
+  return optional ? absl::make_optional(*optional) : absl::nullopt;
+}
+
 template <typename OptionalT1, typename OptionalT2>
 bool OptionalEquals(const OptionalT1& lhs, const OptionalT2& rhs) {
   if (!lhs)

third_party/blink/public/BUILD.gn

@@ -348,6 +348,7 @@ source_set("blink_headers") {
     "platform/web_rtc_rtp_contributing_source.h",
     "platform/web_rtc_rtp_receiver.h",
     "platform/web_rtc_rtp_sender.h",
+    "platform/web_rtc_rtp_transceiver.h",
     "platform/web_rtc_session_description.h",
     "platform/web_rtc_session_description_request.h",
     "platform/web_rtc_stats.h",

third_party/blink/public/platform/web_rtc_rtp_transceiver.h

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_RTC_RTP_TRANSCEIVER_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_RTC_RTP_TRANSCEIVER_H_
+
+#include <vector>
+
+#include "base/optional.h"
+#include "third_party/blink/public/platform/web_common.h"
+#include "third_party/blink/public/platform/web_rtc_rtp_receiver.h"
+#include "third_party/blink/public/platform/web_rtc_rtp_sender.h"
+#include "third_party/blink/public/platform/web_string.h"
+#include "third_party/webrtc/api/rtptransceiverinterface.h"
+
+namespace blink {
+
+// Interface for content to implement as to allow the surfacing of transceivers.
+// TODO(hbos): [Onion Soup] Remove the content layer versions of this class and
+// rely on webrtc directly from blink. Requires coordination with senders and
+// receivers. https://crbug.com/787254
+class BLINK_PLATFORM_EXPORT WebRTCRtpTransceiver {
+ public:
+  virtual ~WebRTCRtpTransceiver();
+
+  // Identifies the webrtc-layer transceiver. Multiple WebRTCRtpTransceiver can
+  // exist for the same webrtc-layer transceiver.
+  virtual uintptr_t Id() const = 0;
+  virtual WebString Mid() const = 0;
+  virtual std::unique_ptr<WebRTCRtpSender> Sender() const = 0;
+  virtual std::unique_ptr<WebRTCRtpReceiver> Receiver() const = 0;
+  virtual bool Stopped() const = 0;
+  virtual webrtc::RtpTransceiverDirection Direction() const = 0;
+  virtual base::Optional<webrtc::RtpTransceiverDirection> CurrentDirection()
+      const = 0;
+  virtual void Stop() = 0;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_RTC_RTP_TRANSCEIVER_H_

third_party/blink/renderer/platform/BUILD.gn

@@ -562,6 +562,7 @@ jumbo_component("platform") {
     "exported/web_rtc_rtp_contributing_source.cc",
     "exported/web_rtc_rtp_receiver.cc",
     "exported/web_rtc_rtp_sender.cc",
+    "exported/web_rtc_rtp_transceiver.cc",
     "exported/web_rtc_session_description.cc",
     "exported/web_rtc_session_description_request.cc",
     "exported/web_rtc_stats.cc",

third_party/blink/renderer/platform/exported/web_rtc_rtp_transceiver.cc

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/blink/public/platform/web_rtc_rtp_transceiver.h"
+
+namespace blink {
+
+WebRTCRtpTransceiver::~WebRTCRtpTransceiver() = default;
+
+}  // namespace blink