Onion soup content/renderer/media/webrtc/rtc_rtp_transceiver.cc|h

... and the respective unittest, rtc_rtp_transceiver_unittest.cc

This CL works out phase 7.3 on the design document [1].

[1] https://docs.google.com/document/d/1AJKVA5U4nDkyDB9p4ROrggWXadCxyy-grKaE9KS5vOU/

In order to avoid colliding files and classes names with
existing homonyms in renderer/modules/peerconnection, the following renames were
performed:

- rtc_rtp_transceiver_impl.cc     -> rtc_rtp_transceiver_impl.cc
- rtc_rtp_transceiver_impl.h      -> rtc_rtp_transceiver_impl.h.h
- rtc_rtp_transceiver_unittest.cc -> rtc_rtp_transceiver_impl_test.cc

Also, RTCRtpTransceiver became RTCRtpTransceiverImpl.

BUG=787254
R=guidou@chromium.org, haraken@chromium.org

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

content/renderer/BUILD.gn

@@ -204,8 +204,6 @@ target(link_target_type, "renderer") {
     "media/webrtc/peer_connection_tracker.h",
     "media/webrtc/rtc_peer_connection_handler.cc",
     "media/webrtc/rtc_peer_connection_handler.h",
-    "media/webrtc/rtc_rtp_transceiver.cc",
-    "media/webrtc/rtc_rtp_transceiver.h",
     "media/webrtc/transceiver_state_surfacer.cc",
     "media/webrtc/transceiver_state_surfacer.h",
     "media/webrtc/webrtc_set_description_observer.cc",

content/renderer/media/webrtc/rtc_peer_connection_handler.cc

@@ -759,7 +759,7 @@ class RTCPeerConnectionHandler::WebRtcSetDescriptionObserverImpl
     }
   }
 
-  bool ReceiverWasAdded(const RtpTransceiverState& transceiver_state) {
+  bool ReceiverWasAdded(const blink::RtpTransceiverState& transceiver_state) {
     DCHECK(handler_);
     uintptr_t receiver_id = blink::RTCRtpReceiverImpl::getId(
         transceiver_state.receiver_state()->webrtc_receiver().get());
@@ -772,7 +772,7 @@ class RTCPeerConnectionHandler::WebRtcSetDescriptionObserverImpl
 
   bool ReceiverWasRemoved(
       const blink::RTCRtpReceiverImpl& receiver,
-      const std::vector<RtpTransceiverState>& transceiver_states) {
+      const std::vector<blink::RtpTransceiverState>& transceiver_states) {
     for (const auto& transceiver_state : transceiver_states) {
       if (transceiver_state.receiver_state()->webrtc_receiver() ==
           receiver.state().webrtc_receiver()) {
@@ -1143,7 +1143,7 @@ RTCPeerConnectionHandler::CreateOfferInternal(
   std::vector<std::unique_ptr<blink::WebRTCRtpTransceiver>> transceivers;
   for (auto& transceiver_state : transceiver_states) {
     auto transceiver = CreateOrUpdateTransceiver(
-        std::move(transceiver_state), TransceiverStateUpdateMode::kAll);
+        std::move(transceiver_state), blink::TransceiverStateUpdateMode::kAll);
     transceivers.push_back(std::move(transceiver));
   }
   return transceivers;
@@ -1623,8 +1623,9 @@ RTCPeerConnectionHandler::AddTransceiverWithTrack(
   }
 
   auto transceiver_states = transceiver_state_surfacer.ObtainStates();
-  auto transceiver = CreateOrUpdateTransceiver(
-      std::move(transceiver_states[0]), TransceiverStateUpdateMode::kAll);
+  auto transceiver =
+      CreateOrUpdateTransceiver(std::move(transceiver_states[0]),
+                                blink::TransceiverStateUpdateMode::kAll);
   std::unique_ptr<blink::WebRTCRtpTransceiver> web_transceiver =
       std::move(transceiver);
   return web_transceiver;
@@ -1677,8 +1678,9 @@ RTCPeerConnectionHandler::AddTransceiverWithKind(
   }
 
   auto transceiver_states = transceiver_state_surfacer.ObtainStates();
-  auto transceiver = CreateOrUpdateTransceiver(
-      std::move(transceiver_states[0]), TransceiverStateUpdateMode::kAll);
+  auto transceiver =
+      CreateOrUpdateTransceiver(std::move(transceiver_states[0]),
+                                blink::TransceiverStateUpdateMode::kAll);
   std::unique_ptr<blink::WebRTCRtpTransceiver> web_transceiver =
       std::move(transceiver);
   return std::move(web_transceiver);
@@ -1758,7 +1760,7 @@ RTCPeerConnectionHandler::AddTrack(
     DCHECK_EQ(configuration_.sdp_semantics, webrtc::SdpSemantics::kUnifiedPlan);
     // Unified Plan: Create or recycle a transceiver.
     auto transceiver = CreateOrUpdateTransceiver(
-        std::move(transceiver_state), TransceiverStateUpdateMode::kAll);
+        std::move(transceiver_state), blink::TransceiverStateUpdateMode::kAll);
     web_transceiver = std::move(transceiver);
   }
   if (peer_connection_tracker_) {
@@ -1896,7 +1898,7 @@ RTCPeerConnectionHandler::RemoveTrackUnifiedPlan(
 
   // Update the transceiver.
   auto transceiver = CreateOrUpdateTransceiver(
-      std::move(transceiver_state), TransceiverStateUpdateMode::kAll);
+      std::move(transceiver_state), blink::TransceiverStateUpdateMode::kAll);
   if (peer_connection_tracker_) {
     size_t transceiver_index = GetTransceiverIndex(*transceiver);
     peer_connection_tracker_->TrackModifyTransceiver(
@@ -2231,7 +2233,7 @@ void RTCPeerConnectionHandler::OnModifySctpTransport(
 }
 
 void RTCPeerConnectionHandler::OnModifyTransceivers(
-    std::vector<RtpTransceiverState> transceiver_states,
+    std::vector<blink::RtpTransceiverState> transceiver_states,
     bool is_remote_description) {
   DCHECK_EQ(configuration_.sdp_semantics, webrtc::SdpSemantics::kUnifiedPlan);
   std::vector<std::unique_ptr<blink::WebRTCRtpTransceiver>> web_transceivers(
@@ -2245,7 +2247,7 @@ void RTCPeerConnectionHandler::OnModifyTransceivers(
     // Figure out if this transceiver is new or if setting the state modified
     // the transceiver such that it should be logged by the
     // |peer_connection_tracker_|.
-    uintptr_t transceiver_id = RTCRtpTransceiver::GetId(
+    uintptr_t transceiver_id = blink::RTCRtpTransceiverImpl::GetId(
         transceiver_states[i].webrtc_transceiver().get());
     auto it = FindTransceiver(transceiver_id);
     bool transceiver_is_new = (it == rtp_transceivers_.end());
@@ -2261,9 +2263,9 @@ void RTCPeerConnectionHandler::OnModifyTransceivers(
     }
 
     // Update the transceiver.
-    web_transceivers[i] =
-        CreateOrUpdateTransceiver(std::move(transceiver_states[i]),
-                                  TransceiverStateUpdateMode::kSetDescription);
+    web_transceivers[i] = CreateOrUpdateTransceiver(
+        std::move(transceiver_states[i]),
+        blink::TransceiverStateUpdateMode::kSetDescription);
 
     // Log a "transceiverAdded" or "transceiverModified" event in
     // chrome://webrtc-internals if new or modified.
@@ -2409,7 +2411,7 @@ RTCPeerConnectionHandler::FindReceiver(uintptr_t id) {
   return rtp_receivers_.end();
 }
 
-std::vector<std::unique_ptr<RTCRtpTransceiver>>::iterator
+std::vector<std::unique_ptr<blink::RTCRtpTransceiverImpl>>::iterator
 RTCPeerConnectionHandler::FindTransceiver(uintptr_t id) {
   for (auto it = rtp_transceivers_.begin(); it != rtp_transceivers_.end();
        ++it) {
@@ -2448,10 +2450,10 @@ size_t RTCPeerConnectionHandler::GetTransceiverIndex(
   return 0u;
 }
 
-std::unique_ptr<RTCRtpTransceiver>
+std::unique_ptr<blink::RTCRtpTransceiverImpl>
 RTCPeerConnectionHandler::CreateOrUpdateTransceiver(
-    RtpTransceiverState transceiver_state,
-    TransceiverStateUpdateMode update_mode) {
+    blink::RtpTransceiverState transceiver_state,
+    blink::TransceiverStateUpdateMode update_mode) {
   DCHECK_EQ(configuration_.sdp_semantics, webrtc::SdpSemantics::kUnifiedPlan);
   DCHECK(transceiver_state.is_initialized());
   DCHECK(transceiver_state.sender_state());
@@ -2460,11 +2462,12 @@ RTCPeerConnectionHandler::CreateOrUpdateTransceiver(
   auto webrtc_sender = transceiver_state.sender_state()->webrtc_sender();
   auto webrtc_receiver = transceiver_state.receiver_state()->webrtc_receiver();
 
-  std::unique_ptr<RTCRtpTransceiver> transceiver;
-  auto it = FindTransceiver(RTCRtpTransceiver::GetId(webrtc_transceiver.get()));
+  std::unique_ptr<blink::RTCRtpTransceiverImpl> transceiver;
+  auto it = FindTransceiver(
+      blink::RTCRtpTransceiverImpl::GetId(webrtc_transceiver.get()));
   if (it == rtp_transceivers_.end()) {
     // Create a new transceiver, including a sender and a receiver.
-    transceiver = std::make_unique<RTCRtpTransceiver>(
+    transceiver = std::make_unique<blink::RTCRtpTransceiverImpl>(
         native_peer_connection_, track_adapter_map_,
         std::move(transceiver_state));
     rtp_transceivers_.push_back(transceiver->ShallowCopy());

content/renderer/media/webrtc/rtc_peer_connection_handler.h

@@ -235,8 +235,9 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   void OnAddReceiverPlanB(blink::RtpReceiverState receiver_state);
   void OnRemoveReceiverPlanB(uintptr_t receiver_id);
   void OnModifySctpTransport(blink::WebRTCSctpTransportSnapshot state);
-  void OnModifyTransceivers(std::vector<RtpTransceiverState> transceiver_states,
-                            bool is_remote_description);
+  void OnModifyTransceivers(
+      std::vector<blink::RtpTransceiverState> transceiver_states,
+      bool is_remote_description);
   void OnDataChannel(scoped_refptr<webrtc::DataChannelInterface> channel);
   void OnIceCandidate(const std::string& sdp,
                       const std::string& sdp_mid,
@@ -321,8 +322,8 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
       uintptr_t id);
   std::vector<std::unique_ptr<blink::RTCRtpReceiverImpl>>::iterator
   FindReceiver(uintptr_t id);
-  std::vector<std::unique_ptr<RTCRtpTransceiver>>::iterator FindTransceiver(
-      uintptr_t id);
+  std::vector<std::unique_ptr<blink::RTCRtpTransceiverImpl>>::iterator
+  FindTransceiver(uintptr_t id);
   // For full transceiver implementations, returns the index of
   // |rtp_transceivers_| that correspond to |web_transceiver|.
   // For sender-only transceiver implementations, returns the index of
@@ -332,9 +333,9 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   // NOTREACHED()-crashes if no correspondent is found.
   size_t GetTransceiverIndex(
       const blink::WebRTCRtpTransceiver& web_transceiver);
-  std::unique_ptr<RTCRtpTransceiver> CreateOrUpdateTransceiver(
-      RtpTransceiverState transceiver_state,
-      TransceiverStateUpdateMode update_mode);
+  std::unique_ptr<blink::RTCRtpTransceiverImpl> CreateOrUpdateTransceiver(
+      blink::RtpTransceiverState transceiver_state,
+      blink::TransceiverStateUpdateMode update_mode);
 
   scoped_refptr<base::SingleThreadTaskRunner> signaling_thread() const;
 
@@ -374,7 +375,7 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   // Content layer correspondents of |webrtc::RtpReceiverInterface|.
   std::vector<std::unique_ptr<blink::RTCRtpReceiverImpl>> rtp_receivers_;
   // Content layer correspondents of |webrtc::RtpTransceiverInterface|.
-  std::vector<std::unique_ptr<RTCRtpTransceiver>> rtp_transceivers_;
+  std::vector<std::unique_ptr<blink::RTCRtpTransceiverImpl>> rtp_transceivers_;
 
   base::WeakPtr<PeerConnectionTracker> peer_connection_tracker_;
 

content/renderer/media/webrtc/transceiver_state_surfacer.cc

@@ -113,7 +113,7 @@ void TransceiverStateSurfacer::Initialize(
           std::move(receiver_track_ref), std::move(receiver_stream_ids));
     }
     // Create the transceiver state.
-    transceiver_states_.push_back(RtpTransceiverState(
+    transceiver_states_.push_back(blink::RtpTransceiverState(
         main_task_runner_, signaling_task_runner_, webrtc_transceiver.get(),
         std::move(sender_state), std::move(receiver_state),
         blink::ToBaseOptional(webrtc_transceiver->mid()),
@@ -131,7 +131,8 @@ TransceiverStateSurfacer::SctpTransportSnapshot() {
   return sctp_transport_snapshot_;
 }
 
-std::vector<RtpTransceiverState> TransceiverStateSurfacer::ObtainStates() {
+std::vector<blink::RtpTransceiverState>
+TransceiverStateSurfacer::ObtainStates() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(is_initialized_);
   for (auto& transceiver_state : transceiver_states_)

content/renderer/media/webrtc/transceiver_state_surfacer.h

@@ -5,8 +5,9 @@
 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_TRANSCEIVER_STATE_SURFACER_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_TRANSCEIVER_STATE_SURFACER_H_
 
-#include "content/renderer/media/webrtc/rtc_rtp_transceiver.h"
+#include "content/common/content_export.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler_client.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_transceiver_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/webrtc/api/rtp_transceiver_interface.h"
 #include "third_party/webrtc/api/sctp_transport_interface.h"
@@ -48,7 +49,7 @@ class CONTENT_EXPORT TransceiverStateSurfacer {
 
   // Must be invoked on the main thread.
   blink::WebRTCSctpTransportSnapshot SctpTransportSnapshot();
-  std::vector<RtpTransceiverState> ObtainStates();
+  std::vector<blink::RtpTransceiverState> ObtainStates();
 
  protected:
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
@@ -56,7 +57,7 @@ class CONTENT_EXPORT TransceiverStateSurfacer {
   bool is_initialized_;
   bool states_obtained_;
   blink::WebRTCSctpTransportSnapshot sctp_transport_snapshot_;
-  std::vector<RtpTransceiverState> transceiver_states_;
+  std::vector<blink::RtpTransceiverState> transceiver_states_;
 };
 
 // A dummy implementation of a transceiver used to surface sender state

content/renderer/media/webrtc/webrtc_set_description_observer.h

@@ -14,10 +14,10 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/webrtc/rtc_peer_connection_handler.h"
-#include "content/renderer/media/webrtc/rtc_rtp_transceiver.h"
 #include "content/renderer/media/webrtc/transceiver_state_surfacer.h"
 #include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_sender_impl.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_transceiver_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/webrtc/api/jsep.h"
 #include "third_party/webrtc/api/peer_connection_interface.h"
@@ -50,7 +50,7 @@ class CONTENT_EXPORT WebRtcSetDescriptionObserver
 
     webrtc::PeerConnectionInterface::SignalingState signaling_state;
     blink::WebRTCSctpTransportSnapshot sctp_transport_state;
-    std::vector<RtpTransceiverState> transceiver_states;
+    std::vector<blink::RtpTransceiverState> transceiver_states;
 
     DISALLOW_COPY_AND_ASSIGN(States);
   };

content/renderer/media/webrtc/webrtc_set_description_observer_unittest.cc

@@ -297,7 +297,7 @@ class WebRtcSetDescriptionObserverHandlerTest
     auto sender = transceiver->sender();
     auto receiver = transceiver->receiver();
     EXPECT_EQ(1u, observer_->states().transceiver_states.size());
-    const RtpTransceiverState& transceiver_state =
+    const blink::RtpTransceiverState& transceiver_state =
         observer_->states().transceiver_states[0];
     // Inspect transceiver states.
     EXPECT_TRUE(transceiver_state.is_initialized());
@@ -350,7 +350,7 @@ class WebRtcSetDescriptionObserverHandlerTest
 
     auto receiver = receivers_[0];
     EXPECT_EQ(1u, observer_->states().transceiver_states.size());
-    const RtpTransceiverState& transceiver_state =
+    const blink::RtpTransceiverState& transceiver_state =
         observer_->states().transceiver_states[0];
     EXPECT_FALSE(transceiver_state.sender_state());
     EXPECT_TRUE(transceiver_state.receiver_state());

content/test/BUILD.gn

@@ -1944,7 +1944,6 @@ test("content_unittests") {
     "../renderer/media/webrtc/peer_connection_dependency_factory_unittest.cc",
     "../renderer/media/webrtc/peer_connection_tracker_unittest.cc",
     "../renderer/media/webrtc/rtc_peer_connection_handler_unittest.cc",
-    "../renderer/media/webrtc/rtc_rtp_transceiver_unittest.cc",
     "../renderer/media/webrtc/task_queue_factory_unittest.cc",
     "../renderer/media/webrtc/transceiver_state_surfacer_unittest.cc",
     "../renderer/media/webrtc/webrtc_audio_renderer_unittest.cc",

third_party/blink/public/BUILD.gn

@@ -388,6 +388,7 @@ source_set("blink_headers") {
     "web/modules/peerconnection/peer_connection_dependency_factory.h",
     "web/modules/peerconnection/rtc_rtp_receiver_impl.h",
     "web/modules/peerconnection/rtc_rtp_sender_impl.h",
+    "web/modules/peerconnection/rtc_rtp_transceiver_impl.h",
     "web/modules/peerconnection/webrtc_media_stream_track_adapter.h",
     "web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h",
     "web/modules/service_worker/web_service_worker_context_client.h",

content/renderer/media/webrtc/rtc_rtp_transceiver.h → third_party/blink/public/web/modules/peerconnection/rtc_rtp_transceiver_impl.h

@@ -2,20 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_TRANSCEIVER_H_
-#define CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_TRANSCEIVER_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_PEERCONNECTION_RTC_RTP_TRANSCEIVER_IMPL_H_
+#define THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_PEERCONNECTION_RTC_RTP_TRANSCEIVER_IMPL_H_
 
 #include "base/memory/scoped_refptr.h"
 #include "base/optional.h"
 #include "base/single_thread_task_runner.h"
-#include "content/common/content_export.h"
+#include "third_party/blink/public/platform/web_common.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_transceiver.h"
 #include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_sender_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/webrtc/api/rtp_transceiver_interface.h"
 
-namespace content {
+namespace blink {
 
 // This class represents the state of a transceiver; a snapshot of what a
 // webrtc-layer transceiver looked like when it was inspected on the signaling
@@ -50,10 +50,13 @@ namespace content {
 // Except for initialization logic and operator=(), the RtpTransceiverState is
 // immutable and only accessible on the main thread.
 //
-// TODO(hbos): [Onion Soup] When the transceiver implementation is moved to
-// blink this will be part of the blink transceiver instead of the content
-// transceiver. https://crbug.com/787254
-class CONTENT_EXPORT RtpTransceiverState {
+// TODO(crbug.com/787254): Move the classes below out of the Blink exposed API.
+// Also, consider merging RTCRtpTransceiverImpl and RTCRtpTransceiver
+// (requires coordination with senders and receivers) and
+// removing WebRTCRtpTransceiver when all its clients are Onion soup'ed.
+//
+// Last, move away from using std::vector.
+class BLINK_MODULES_EXPORT RtpTransceiverState {
  public:
   RtpTransceiverState(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
@@ -107,13 +110,13 @@ class CONTENT_EXPORT RtpTransceiverState {
   base::Optional<webrtc::RtpTransceiverDirection> fired_direction_;
 };
 
-// RTCRtpTransceiver::set_state() performs differently depending on the update
-// mode. The update mode exists to get around problems with the webrtc threading
-// model: https://crbug.com/webrtc/8692.
+// RTCRtpTransceiverImpl::set_state() performs differently depending on the
+// update mode. The update mode exists to get around problems with the webrtc
+// threading model: https://crbug.com/webrtc/8692.
 //
 // Transceiver state information can be surfaced as a result of invoking a
 // number of different JavaScript APIs. The way states are surfaced from webrtc
-// to content/blink fall into two categories:
+// to blink fall into two categories:
 //   Blocking operations and callback-based operations.
 //
 // When a blocking operation is invoked, the main thread is blocked on the
@@ -125,7 +128,7 @@ class CONTENT_EXPORT RtpTransceiverState {
 // addTrack() - doesn't happen in-between the posting of the task and the
 // execution of it. In such cases, the state information surfaced might not be
 // up-to-date (in edge cases). Examples of callback-based operations include
-// setLocalDescription() and setRemoteDescription().
+// setLocalDescripti.on() and setRemoteDescription().
 enum class TransceiverStateUpdateMode {
   // In this mode, all state information is updated. Use this enum unless
   // a different update mode applies.
@@ -138,27 +141,25 @@ enum class TransceiverStateUpdateMode {
 };
 
 // Used to surface |webrtc::RtpTransceiverInterface| to blink. Multiple
-// |RTCRtpTransceiver|s could reference the same webrtc transceiver; |id| is
+// |RTCRtpTransceiverImpl|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 {
+class BLINK_MODULES_EXPORT RTCRtpTransceiverImpl
+    : public blink::WebRTCRtpTransceiver {
  public:
   static uintptr_t GetId(
       const webrtc::RtpTransceiverInterface* webrtc_transceiver);
 
-  RTCRtpTransceiver(
+  RTCRtpTransceiverImpl(
       scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
       scoped_refptr<blink::WebRtcMediaStreamTrackAdapterMap> track_map,
       RtpTransceiverState state);
-  RTCRtpTransceiver(const RTCRtpTransceiver& other);
-  ~RTCRtpTransceiver() override;
+  RTCRtpTransceiverImpl(const RTCRtpTransceiverImpl& other);
+  ~RTCRtpTransceiverImpl() override;
 
-  RTCRtpTransceiver& operator=(const RTCRtpTransceiver& other);
-  std::unique_ptr<RTCRtpTransceiver> ShallowCopy() const;
+  RTCRtpTransceiverImpl& operator=(const RTCRtpTransceiverImpl& other);
+  std::unique_ptr<RTCRtpTransceiverImpl> ShallowCopy() const;
 
   const RtpTransceiverState& state() const;
   void set_state(RtpTransceiverState state,
@@ -189,6 +190,6 @@ class CONTENT_EXPORT RTCRtpTransceiver : public blink::WebRTCRtpTransceiver {
   scoped_refptr<RTCRtpTransceiverInternal> internal_;
 };
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_TRANSCEIVER_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_PEERCONNECTION_RTC_RTP_TRANSCEIVER_IMPL_H_

third_party/blink/renderer/modules/BUILD.gn

@@ -392,6 +392,7 @@ jumbo_source_set("unit_tests") {
     "peerconnection/rtc_quic_transport_test.h",
     "peerconnection/rtc_rtp_receiver_impl_test.cc",
     "peerconnection/rtc_rtp_sender_impl_test.cc",
+    "peerconnection/rtc_rtp_transceiver_impl_test.cc",
     "peerconnection/rtc_sctp_transport_test.cc",
     "peerconnection/webrtc_media_stream_track_adapter_map_test.cc",
     "peerconnection/webrtc_media_stream_track_adapter_test.cc",

third_party/blink/renderer/modules/peerconnection/BUILD.gn

@@ -103,6 +103,7 @@ blink_modules_sources("peerconnection") {
     "rtc_rtp_sender_impl.cc",
     "rtc_rtp_transceiver.cc",
     "rtc_rtp_transceiver.h",
+    "rtc_rtp_transceiver_impl.cc",
     "rtc_sctp_transport.cc",
     "rtc_sctp_transport.h",
     "rtc_session_description.cc",

content/renderer/media/webrtc/rtc_rtp_transceiver.cc → third_party/blink/renderer/modules/peerconnection/rtc_rtp_transceiver_impl.cc

@@ -2,13 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/media/webrtc/rtc_rtp_transceiver.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_transceiver_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/ref_counted.h"
+#include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
+#include "third_party/webrtc/api/scoped_refptr.h"
 
-namespace content {
+namespace blink {
 
 RtpTransceiverState::RtpTransceiverState(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
@@ -173,10 +174,10 @@ RtpTransceiverState::fired_direction() const {
   return fired_direction_;
 }
 
-class RTCRtpTransceiver::RTCRtpTransceiverInternal
-    : public base::RefCountedThreadSafe<
-          RTCRtpTransceiver::RTCRtpTransceiverInternal,
-          RTCRtpTransceiver::RTCRtpTransceiverInternalTraits> {
+class RTCRtpTransceiverImpl::RTCRtpTransceiverInternal
+    : public WTF::ThreadSafeRefCounted<
+          RTCRtpTransceiverImpl::RTCRtpTransceiverInternal,
+          RTCRtpTransceiverImpl::RTCRtpTransceiverInternalTraits> {
  public:
   RTCRtpTransceiverInternal(
       scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
@@ -246,7 +247,9 @@ class RTCRtpTransceiver::RTCRtpTransceiverInternal
   }
 
  private:
-  friend struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits;
+  friend class WTF::ThreadSafeRefCounted<RTCRtpTransceiverInternal,
+                                         RTCRtpTransceiverInternalTraits>;
+  friend struct RTCRtpTransceiverImpl::RTCRtpTransceiverInternalTraits;
 
   ~RTCRtpTransceiverInternal() {
     // Ensured by destructor traits.
@@ -264,11 +267,7 @@ class RTCRtpTransceiver::RTCRtpTransceiverInternal
   std::unique_ptr<blink::RTCRtpReceiverImpl> receiver_;
 };
 
-struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits {
- private:
-  friend class base::RefCountedThreadSafe<RTCRtpTransceiverInternal,
-                                          RTCRtpTransceiverInternalTraits>;
-
+struct RTCRtpTransceiverImpl::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.
@@ -276,7 +275,7 @@ struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits {
       transceiver->main_task_runner_->PostTask(
           FROM_HERE,
           base::BindOnce(
-              &RTCRtpTransceiver::RTCRtpTransceiverInternalTraits::Destruct,
+              &RTCRtpTransceiverImpl::RTCRtpTransceiverInternalTraits::Destruct,
               base::Unretained(transceiver)));
       return;
     }
@@ -284,99 +283,102 @@ struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits {
   }
 };
 
-uintptr_t RTCRtpTransceiver::GetId(
+uintptr_t RTCRtpTransceiverImpl::GetId(
     const webrtc::RtpTransceiverInterface* webrtc_transceiver) {
   return reinterpret_cast<uintptr_t>(webrtc_transceiver);
 }
 
-RTCRtpTransceiver::RTCRtpTransceiver(
+RTCRtpTransceiverImpl::RTCRtpTransceiverImpl(
     scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
     scoped_refptr<blink::WebRtcMediaStreamTrackAdapterMap> track_map,
     RtpTransceiverState transceiver_state)
-    : internal_(new RTCRtpTransceiverInternal(std::move(native_peer_connection),
-                                              std::move(track_map),
-                                              std::move(transceiver_state))) {}
+    : internal_(base::MakeRefCounted<RTCRtpTransceiverInternal>(
+          std::move(native_peer_connection),
+          std::move(track_map),
+          std::move(transceiver_state))) {}
 
-RTCRtpTransceiver::RTCRtpTransceiver(const RTCRtpTransceiver& other)
+RTCRtpTransceiverImpl::RTCRtpTransceiverImpl(const RTCRtpTransceiverImpl& other)
     : internal_(other.internal_) {}
 
-RTCRtpTransceiver::~RTCRtpTransceiver() {}
+RTCRtpTransceiverImpl::~RTCRtpTransceiverImpl() {}
 
-RTCRtpTransceiver& RTCRtpTransceiver::operator=(
-    const RTCRtpTransceiver& other) {
+RTCRtpTransceiverImpl& RTCRtpTransceiverImpl::operator=(
+    const RTCRtpTransceiverImpl& other) {
   internal_ = other.internal_;
   return *this;
 }
 
-std::unique_ptr<RTCRtpTransceiver> RTCRtpTransceiver::ShallowCopy() const {
-  return std::make_unique<RTCRtpTransceiver>(*this);
+std::unique_ptr<RTCRtpTransceiverImpl> RTCRtpTransceiverImpl::ShallowCopy()
+    const {
+  return std::make_unique<RTCRtpTransceiverImpl>(*this);
 }
 
-const RtpTransceiverState& RTCRtpTransceiver::state() const {
+const RtpTransceiverState& RTCRtpTransceiverImpl::state() const {
   return internal_->state();
 }
 
-blink::RTCRtpSenderImpl* RTCRtpTransceiver::content_sender() {
+blink::RTCRtpSenderImpl* RTCRtpTransceiverImpl::content_sender() {
   return internal_->content_sender();
 }
 
-blink::RTCRtpReceiverImpl* RTCRtpTransceiver::content_receiver() {
+blink::RTCRtpReceiverImpl* RTCRtpTransceiverImpl::content_receiver() {
   return internal_->content_receiver();
 }
 
-void RTCRtpTransceiver::set_state(RtpTransceiverState transceiver_state,
-                                  TransceiverStateUpdateMode update_mode) {
+void RTCRtpTransceiverImpl::set_state(RtpTransceiverState transceiver_state,
+                                      TransceiverStateUpdateMode update_mode) {
   internal_->set_state(std::move(transceiver_state), update_mode);
 }
 
 blink::WebRTCRtpTransceiverImplementationType
-RTCRtpTransceiver::ImplementationType() const {
+RTCRtpTransceiverImpl::ImplementationType() const {
   return blink::WebRTCRtpTransceiverImplementationType::kFullTransceiver;
 }
 
-uintptr_t RTCRtpTransceiver::Id() const {
+uintptr_t RTCRtpTransceiverImpl::Id() const {
   return GetId(internal_->state().webrtc_transceiver().get());
 }
 
-blink::WebString RTCRtpTransceiver::Mid() const {
+blink::WebString RTCRtpTransceiverImpl::Mid() const {
   const auto& mid = internal_->state().mid();
   return mid ? blink::WebString::FromUTF8(*mid)
              : blink::WebString();  // IsNull()
 }
 
-std::unique_ptr<blink::WebRTCRtpSender> RTCRtpTransceiver::Sender() const {
+std::unique_ptr<blink::WebRTCRtpSender> RTCRtpTransceiverImpl::Sender() const {
   return internal_->content_sender()->ShallowCopy();
 }
 
-std::unique_ptr<blink::WebRTCRtpReceiver> RTCRtpTransceiver::Receiver() const {
+std::unique_ptr<blink::WebRTCRtpReceiver> RTCRtpTransceiverImpl::Receiver()
+    const {
   return internal_->content_receiver()->ShallowCopy();
 }
 
-bool RTCRtpTransceiver::Stopped() const {
+bool RTCRtpTransceiverImpl::Stopped() const {
   return internal_->state().stopped();
 }
 
-webrtc::RtpTransceiverDirection RTCRtpTransceiver::Direction() const {
+webrtc::RtpTransceiverDirection RTCRtpTransceiverImpl::Direction() const {
   return internal_->state().direction();
 }
 
-void RTCRtpTransceiver::SetDirection(
+void RTCRtpTransceiverImpl::SetDirection(
     webrtc::RtpTransceiverDirection direction) {
   internal_->SetDirection(direction);
 }
 
 base::Optional<webrtc::RtpTransceiverDirection>
-RTCRtpTransceiver::CurrentDirection() const {
+RTCRtpTransceiverImpl::CurrentDirection() const {
   return internal_->state().current_direction();
 }
 
 base::Optional<webrtc::RtpTransceiverDirection>
-RTCRtpTransceiver::FiredDirection() const {
+RTCRtpTransceiverImpl::FiredDirection() const {
   return internal_->state().fired_direction();
 }
 
-webrtc::RTCError RTCRtpTransceiver::SetCodecPreferences(
+webrtc::RTCError RTCRtpTransceiverImpl::SetCodecPreferences(
     blink::WebVector<webrtc::RtpCodecCapability> codec_preferences) {
   return internal_->setCodecPreferences(codec_preferences.ReleaseVector());
 }
-}  // namespace content
+}  // namespace blink

content/renderer/media/webrtc/rtc_rtp_transceiver_unittest.cc → third_party/blink/renderer/modules/peerconnection/rtc_rtp_transceiver_impl_test.cc

@@ -2,20 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/media/webrtc/rtc_rtp_transceiver.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_transceiver_impl.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/task_environment.h"
 #include "build/build_config.h"
-#include "content/child/child_process.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/modules/mediastream/media_stream_audio_source.h"
 #include "third_party/blink/public/platform/modules/peerconnection/webrtc_util.h"
@@ -26,12 +24,13 @@
 #include "third_party/blink/public/web/modules/peerconnection/mock_peer_connection_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/blink/public/web/web_heap.h"
+#include "third_party/blink/renderer/platform/testing/io_task_runner_testing_platform_support.h"
 #include "third_party/webrtc/api/test/mock_rtpreceiver.h"
 #include "third_party/webrtc/api/test/mock_rtpsender.h"
 
-namespace content {
+namespace blink {
 
-class RTCRtpTransceiverTest : public ::testing::Test {
+class RTCRtpTransceiverImplTest : public ::testing::Test {
  public:
   void SetUp() override {
     dependency_factory_.reset(new blink::MockPeerConnectionDependencyFactory());
@@ -78,10 +77,11 @@ class RTCRtpTransceiverTest : public ::testing::Test {
     base::RunLoop run_loop;
     signaling_task_runner()->PostTask(
         FROM_HERE,
-        base::BindOnce(
-            &RTCRtpTransceiverTest::CreateRemoteTrackAdapterOnSignalingThread,
-            base::Unretained(this), std::move(webrtc_track),
-            base::Unretained(&track_ref), base::Unretained(&run_loop)));
+        base::BindOnce(&RTCRtpTransceiverImplTest::
+                           CreateRemoteTrackAdapterOnSignalingThread,
+                       base::Unretained(this), std::move(webrtc_track),
+                       base::Unretained(&track_ref),
+                       base::Unretained(&run_loop)));
     run_loop.Run();
     DCHECK(track_ref);
     return track_ref;
@@ -177,7 +177,7 @@ class RTCRtpTransceiverTest : public ::testing::Test {
   }
 
  private:
-  base::test::SingleThreadTaskEnvironment task_environment_;
+  ScopedTestingPlatformSupport<IOTaskRunnerTestingPlatformSupport> platform_;
 
  protected:
   std::unique_ptr<blink::MockPeerConnectionDependencyFactory>
@@ -187,7 +187,7 @@ class RTCRtpTransceiverTest : public ::testing::Test {
   rtc::scoped_refptr<blink::MockPeerConnectionImpl> peer_connection_;
 };
 
-TEST_F(RTCRtpTransceiverTest, InitializeTransceiverState) {
+TEST_F(RTCRtpTransceiverImplTest, InitializeTransceiverState) {
   auto local_track_adapter = CreateLocalTrackAndAdapter("local_track");
   auto remote_track_adapter = CreateRemoteTrackAndAdapter("remote_track");
   auto webrtc_transceiver = CreateWebRtcTransceiver(
@@ -238,7 +238,7 @@ TEST_F(RTCRtpTransceiverTest, InitializeTransceiverState) {
                                     webrtc_transceiver->fired_direction()));
 }
 
-TEST_F(RTCRtpTransceiverTest, CreateTranceiver) {
+TEST_F(RTCRtpTransceiverImplTest, CreateTranceiver) {
   auto local_track_adapter = CreateLocalTrackAndAdapter("local_track");
   auto remote_track_adapter = CreateRemoteTrackAndAdapter("remote_track");
   auto webrtc_transceiver = CreateWebRtcTransceiver(
@@ -253,8 +253,8 @@ TEST_F(RTCRtpTransceiverTest, CreateTranceiver) {
   EXPECT_FALSE(transceiver_state.is_initialized());
   transceiver_state.Initialize();
 
-  RTCRtpTransceiver transceiver(peer_connection_.get(), track_map_,
-                                std::move(transceiver_state));
+  RTCRtpTransceiverImpl transceiver(peer_connection_.get(), track_map_,
+                                    std::move(transceiver_state));
   EXPECT_TRUE(transceiver.Mid().IsNull());
   EXPECT_TRUE(transceiver.Sender());
   EXPECT_TRUE(transceiver.Receiver());
@@ -265,7 +265,7 @@ TEST_F(RTCRtpTransceiverTest, CreateTranceiver) {
   EXPECT_FALSE(transceiver.FiredDirection());
 }
 
-TEST_F(RTCRtpTransceiverTest, ModifyTransceiver) {
+TEST_F(RTCRtpTransceiverImplTest, ModifyTransceiver) {
   auto local_track_adapter = CreateLocalTrackAndAdapter("local_track");
   auto remote_track_adapter = CreateRemoteTrackAndAdapter("remote_track");
   auto webrtc_sender =
@@ -297,8 +297,8 @@ TEST_F(RTCRtpTransceiverTest, ModifyTransceiver) {
 
   // Modifying the webrtc transceiver after the initial state was created should
   // not have affected the transceiver state.
-  RTCRtpTransceiver transceiver(peer_connection_.get(), track_map_,
-                                std::move(initial_transceiver_state));
+  RTCRtpTransceiverImpl transceiver(peer_connection_.get(), track_map_,
+                                    std::move(initial_transceiver_state));
   EXPECT_TRUE(transceiver.Mid().IsNull());
   EXPECT_TRUE(transceiver.Sender());
   EXPECT_TRUE(transceiver.Receiver());
@@ -322,7 +322,7 @@ TEST_F(RTCRtpTransceiverTest, ModifyTransceiver) {
   EXPECT_FALSE(transceiver.FiredDirection());
 }
 
-TEST_F(RTCRtpTransceiverTest, ShallowCopy) {
+TEST_F(RTCRtpTransceiverImplTest, ShallowCopy) {
   auto local_track_adapter = CreateLocalTrackAndAdapter("local_track");
   auto remote_track_adapter = CreateRemoteTrackAndAdapter("remote_track");
   auto webrtc_sender =
@@ -333,7 +333,7 @@ TEST_F(RTCRtpTransceiverTest, ShallowCopy) {
       webrtc_sender, webrtc_receiver, base::nullopt, false /* stopped */,
       webrtc::RtpTransceiverDirection::kSendRecv, base::nullopt);
 
-  std::unique_ptr<RTCRtpTransceiver> transceiver;
+  std::unique_ptr<RTCRtpTransceiverImpl> transceiver;
   // Create transceiver.
   {
     RtpTransceiverState transceiver_state =
@@ -341,13 +341,14 @@ TEST_F(RTCRtpTransceiverTest, ShallowCopy) {
                                remote_track_adapter->Copy());
     EXPECT_FALSE(transceiver_state.is_initialized());
     transceiver_state.Initialize();
-    transceiver.reset(new RTCRtpTransceiver(peer_connection_.get(), track_map_,
-                                            std::move(transceiver_state)));
+    transceiver.reset(new RTCRtpTransceiverImpl(
+        peer_connection_.get(), track_map_, std::move(transceiver_state)));
   }
   DCHECK(transceiver);
   EXPECT_FALSE(transceiver->Stopped());
 
-  std::unique_ptr<RTCRtpTransceiver> shallow_copy = transceiver->ShallowCopy();
+  std::unique_ptr<RTCRtpTransceiverImpl> shallow_copy =
+      transceiver->ShallowCopy();
   // Modifying the shallow copy should modify the original too since they have a
   // shared internal state.
   {
@@ -368,7 +369,7 @@ TEST_F(RTCRtpTransceiverTest, ShallowCopy) {
   EXPECT_TRUE(transceiver->Stopped());
 }
 
-TEST_F(RTCRtpTransceiverTest, TransceiverStateUpdateModeSetDescription) {
+TEST_F(RTCRtpTransceiverImplTest, TransceiverStateUpdateModeSetDescription) {
   auto local_track_adapter = CreateLocalTrackAndAdapter("local_track");
   auto remote_track_adapter = CreateRemoteTrackAndAdapter("remote_track");
   auto webrtc_sender =
@@ -400,8 +401,8 @@ TEST_F(RTCRtpTransceiverTest, TransceiverStateUpdateModeSetDescription) {
   modified_transceiver_state.Initialize();
 
   // Construct a transceiver from the initial state.
-  RTCRtpTransceiver transceiver(peer_connection_.get(), track_map_,
-                                std::move(initial_transceiver_state));
+  RTCRtpTransceiverImpl transceiver(peer_connection_.get(), track_map_,
+                                    std::move(initial_transceiver_state));
   // Setting the state with TransceiverStateUpdateMode::kSetDescription should
   // make the transceiver state up-to-date, except leaving
   // "transceiver.direction" and "transceiver.sender.track" unmodified.
@@ -422,4 +423,4 @@ TEST_F(RTCRtpTransceiverTest, TransceiverStateUpdateModeSetDescription) {
             webrtc::RtpTransceiverDirection::kSendRecv);
 }
 
-}  // namespace content
+}  // namespace blink