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

... and the respective unittest, rtc_rtp_receiver_unittest.cc

This CL works out phase 7.1 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_receiver.cc     -> rtc_rtp_receiver_impl.cc
- rtc_rtp_receiver.h      -> rtc_rtp_receiver_impl.h
- rtc_rtp_receiver_unittest.cc -> rtc_rtp_receiver_impl_test.cc

Also, RTCRtpReceiver became RTCRtpReceiverImpl.

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

Change-Id: I4e13b647da1f329868dadd7e59cc13cdc8963797
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1819801
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@{#704969}

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_receiver.cc",
-    "media/webrtc/rtc_rtp_receiver.h",
     "media/webrtc/rtc_rtp_sender.cc",
     "media/webrtc/rtc_rtp_sender.h",
     "media/webrtc/rtc_rtp_transceiver.cc",

content/renderer/media/webrtc/peer_connection_tracker_unittest.cc

@@ -112,7 +112,7 @@ std::unique_ptr<blink::WebRTCRtpTransceiver> CreateDefaultTransceiver(
     DCHECK_EQ(
         implementation_type,
         blink::WebRTCRtpTransceiverImplementationType::kPlanBReceiverOnly);
-    transceiver = std::make_unique<RTCRtpReceiverOnlyTransceiver>(
+    transceiver = std::make_unique<blink::RTCRtpReceiverOnlyTransceiver>(
         std::make_unique<FakeRTCRtpReceiver>(receiver));
   }
   return transceiver;

content/renderer/media/webrtc/rtc_peer_connection_handler.cc

@@ -53,6 +53,7 @@
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_constraints_util.h"
 #include "third_party/blink/public/web/modules/peerconnection/peer_connection_dependency_factory.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_impl.h"
 #include "third_party/blink/public/web/modules/webrtc/webrtc_audio_device_impl.h"
 #include "third_party/webrtc/api/rtc_event_log_output.h"
 #include "third_party/webrtc/pc/media_session.h"
@@ -582,7 +583,8 @@ size_t GetLocalStreamUsageCount(
 }
 
 bool IsRemoteStream(
-    const std::vector<std::unique_ptr<RTCRtpReceiver>>& rtp_receivers,
+    const std::vector<std::unique_ptr<blink::RTCRtpReceiverImpl>>&
+        rtp_receivers,
     const std::string& stream_id) {
   for (const auto& receiver : rtp_receivers) {
     for (const auto& receiver_stream_id : receiver->state().stream_ids()) {
@@ -593,7 +595,6 @@ bool IsRemoteStream(
   return false;
 }
 
-
 MediaStreamTrackMetrics::Kind MediaStreamTrackMetricsKind(
     const blink::WebMediaStreamTrack& track) {
   return track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio
@@ -734,7 +735,7 @@ class RTCPeerConnectionHandler::WebRtcSetDescriptionObserverImpl
 
     // Determine which receivers have been removed before processing the
     // removal as to not invalidate the iterator.
-    std::vector<RTCRtpReceiver*> removed_receivers;
+    std::vector<blink::RTCRtpReceiverImpl*> removed_receivers;
     for (auto it = handler_->rtp_receivers_.begin();
          it != handler_->rtp_receivers_.end(); ++it) {
       if (ReceiverWasRemoved(*(*it), states.transceiver_states))
@@ -752,7 +753,7 @@ class RTCPeerConnectionHandler::WebRtcSetDescriptionObserverImpl
     for (auto* removed_receiver : removed_receivers) {
       if (handler_) {
         // |handler_| can become null after this call.
-        handler_->OnRemoveReceiverPlanB(RTCRtpReceiver::getId(
+        handler_->OnRemoveReceiverPlanB(blink::RTCRtpReceiverImpl::getId(
             removed_receiver->state().webrtc_receiver().get()));
       }
     }
@@ -760,7 +761,7 @@ class RTCPeerConnectionHandler::WebRtcSetDescriptionObserverImpl
 
   bool ReceiverWasAdded(const RtpTransceiverState& transceiver_state) {
     DCHECK(handler_);
-    uintptr_t receiver_id = RTCRtpReceiver::getId(
+    uintptr_t receiver_id = blink::RTCRtpReceiverImpl::getId(
         transceiver_state.receiver_state()->webrtc_receiver().get());
     for (const auto& receiver : handler_->rtp_receivers_) {
       if (receiver->Id() == receiver_id)
@@ -770,7 +771,7 @@ class RTCPeerConnectionHandler::WebRtcSetDescriptionObserverImpl
   }
 
   bool ReceiverWasRemoved(
-      const RTCRtpReceiver& receiver,
+      const blink::RTCRtpReceiverImpl& receiver,
       const std::vector<RtpTransceiverState>& transceiver_states) {
     for (const auto& transceiver_state : transceiver_states) {
       if (transceiver_state.receiver_state()->webrtc_receiver() ==
@@ -2156,7 +2157,7 @@ void RTCPeerConnectionHandler::OnRenegotiationNeeded() {
 }
 
 void RTCPeerConnectionHandler::OnAddReceiverPlanB(
-    RtpReceiverState receiver_state) {
+    blink::RtpReceiverState receiver_state) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(receiver_state.is_initialized());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnAddReceiverPlanB");
@@ -2172,15 +2173,16 @@ void RTCPeerConnectionHandler::OnAddReceiverPlanB(
           ->IncrementStreamCounter();
   }
   uintptr_t receiver_id =
-      RTCRtpReceiver::getId(receiver_state.webrtc_receiver().get());
+      blink::RTCRtpReceiverImpl::getId(receiver_state.webrtc_receiver().get());
   DCHECK(FindReceiver(receiver_id) == rtp_receivers_.end());
-  auto rtp_receiver = std::make_unique<RTCRtpReceiver>(
+  auto rtp_receiver = std::make_unique<blink::RTCRtpReceiverImpl>(
       native_peer_connection_, std::move(receiver_state));
-  rtp_receivers_.push_back(std::make_unique<RTCRtpReceiver>(*rtp_receiver));
+  rtp_receivers_.push_back(
+      std::make_unique<blink::RTCRtpReceiverImpl>(*rtp_receiver));
   if (peer_connection_tracker_) {
     auto receiver_only_transceiver =
-        std::make_unique<RTCRtpReceiverOnlyTransceiver>(
-            std::make_unique<RTCRtpReceiver>(*rtp_receiver));
+        std::make_unique<blink::RTCRtpReceiverOnlyTransceiver>(
+            std::make_unique<blink::RTCRtpReceiverImpl>(*rtp_receiver));
     size_t receiver_index = GetTransceiverIndex(*receiver_only_transceiver);
     peer_connection_tracker_->TrackAddTransceiver(
         this,
@@ -2197,15 +2199,15 @@ void RTCPeerConnectionHandler::OnRemoveReceiverPlanB(uintptr_t receiver_id) {
 
   auto it = FindReceiver(receiver_id);
   DCHECK(it != rtp_receivers_.end());
-  auto receiver = std::make_unique<RTCRtpReceiver>(*(*it));
+  auto receiver = std::make_unique<blink::RTCRtpReceiverImpl>(*(*it));
   // Update metrics.
   track_metrics_.RemoveTrack(MediaStreamTrackMetrics::Direction::kReceive,
                              MediaStreamTrackMetricsKind(receiver->Track()),
                              receiver->Track().Id().Utf8());
   if (peer_connection_tracker_) {
     auto receiver_only_transceiver =
-        std::make_unique<RTCRtpReceiverOnlyTransceiver>(
-            std::make_unique<RTCRtpReceiver>(*receiver));
+        std::make_unique<blink::RTCRtpReceiverOnlyTransceiver>(
+            std::make_unique<blink::RTCRtpReceiverImpl>(*receiver));
     size_t receiver_index = GetTransceiverIndex(*receiver_only_transceiver);
     peer_connection_tracker_->TrackRemoveTransceiver(
         this,
@@ -2398,7 +2400,7 @@ RTCPeerConnectionHandler::FindSender(uintptr_t id) {
   return rtp_senders_.end();
 }
 
-std::vector<std::unique_ptr<RTCRtpReceiver>>::iterator
+std::vector<std::unique_ptr<blink::RTCRtpReceiverImpl>>::iterator
 RTCPeerConnectionHandler::FindReceiver(uintptr_t id) {
   for (auto it = rtp_receivers_.begin(); it != rtp_receivers_.end(); ++it) {
     if ((*it)->Id() == id)
@@ -2470,18 +2472,18 @@ RTCPeerConnectionHandler::CreateOrUpdateTransceiver(
            rtp_senders_.end());
     rtp_senders_.push_back(
         std::make_unique<RTCRtpSender>(*transceiver->content_sender()));
-    DCHECK(FindReceiver(RTCRtpReceiver::getId(webrtc_receiver.get())) ==
-           rtp_receivers_.end());
-    rtp_receivers_.push_back(
-        std::make_unique<RTCRtpReceiver>(*transceiver->content_receiver()));
+    DCHECK(FindReceiver(blink::RTCRtpReceiverImpl::getId(
+               webrtc_receiver.get())) == rtp_receivers_.end());
+    rtp_receivers_.push_back(std::make_unique<blink::RTCRtpReceiverImpl>(
+        *transceiver->content_receiver()));
   } else {
     // Update the transceiver. This also updates the sender and receiver.
     transceiver = (*it)->ShallowCopy();
     transceiver->set_state(std::move(transceiver_state), update_mode);
     DCHECK(FindSender(RTCRtpSender::getId(webrtc_sender.get())) !=
            rtp_senders_.end());
-    DCHECK(FindReceiver(RTCRtpReceiver::getId(webrtc_receiver.get())) !=
-           rtp_receivers_.end());
+    DCHECK(FindReceiver(blink::RTCRtpReceiverImpl::getId(
+               webrtc_receiver.get())) != rtp_receivers_.end());
   }
   return transceiver;
 }

content/renderer/media/webrtc/rtc_peer_connection_handler.h

@@ -20,7 +20,6 @@
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #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/transceiver_state_surfacer.h"
 #include "third_party/blink/public/platform/web_media_stream_source.h"
@@ -29,6 +28,7 @@
 #include "third_party/blink/public/platform/web_rtc_stats.h"
 #include "third_party/blink/public/platform/web_rtc_stats_request.h"
 #include "third_party/blink/public/platform/web_rtc_stats_response.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_impl.h"
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/webrtc/api/stats/rtc_stats.h"
 #include "third_party/webrtc/api/stats/rtc_stats_collector_callback.h"
@@ -232,7 +232,7 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   void OnIceGatheringChange(
       webrtc::PeerConnectionInterface::IceGatheringState new_state);
   void OnRenegotiationNeeded();
-  void OnAddReceiverPlanB(RtpReceiverState receiver_state);
+  void OnAddReceiverPlanB(blink::RtpReceiverState receiver_state);
   void OnRemoveReceiverPlanB(uintptr_t receiver_id);
   void OnModifySctpTransport(blink::WebRTCSctpTransportSnapshot state);
   void OnModifyTransceivers(std::vector<RtpTransceiverState> transceiver_states,
@@ -318,8 +318,8 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
       webrtc::PeerConnectionInterface::RTCOfferAnswerOptions offer_options,
       TransceiverStateSurfacer* transceiver_state_surfacer);
   std::vector<std::unique_ptr<RTCRtpSender>>::iterator FindSender(uintptr_t id);
-  std::vector<std::unique_ptr<RTCRtpReceiver>>::iterator FindReceiver(
-      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);
   // For full transceiver implementations, returns the index of
@@ -371,7 +371,7 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   // Content layer correspondents of |webrtc::RtpSenderInterface|.
   std::vector<std::unique_ptr<RTCRtpSender>> rtp_senders_;
   // Content layer correspondents of |webrtc::RtpReceiverInterface|.
-  std::vector<std::unique_ptr<RTCRtpReceiver>> rtp_receivers_;
+  std::vector<std::unique_ptr<blink::RTCRtpReceiverImpl>> rtp_receivers_;
   // Content layer correspondents of |webrtc::RtpTransceiverInterface|.
   std::vector<std::unique_ptr<RTCRtpTransceiver>> rtp_transceivers_;
 

content/renderer/media/webrtc/rtc_rtp_transceiver.cc

@@ -15,7 +15,7 @@ RtpTransceiverState::RtpTransceiverState(
     scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
     scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver,
     base::Optional<RtpSenderState> sender_state,
-    base::Optional<RtpReceiverState> receiver_state,
+    base::Optional<blink::RtpReceiverState> receiver_state,
     base::Optional<std::string> mid,
     bool stopped,
     webrtc::RtpTransceiverDirection direction,
@@ -127,15 +127,15 @@ RtpSenderState RtpTransceiverState::MoveSenderState() {
   return *std::move(temp);
 }
 
-const base::Optional<RtpReceiverState>& RtpTransceiverState::receiver_state()
-    const {
+const base::Optional<blink::RtpReceiverState>&
+RtpTransceiverState::receiver_state() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return receiver_state_;
 }
 
-RtpReceiverState RtpTransceiverState::MoveReceiverState() {
+blink::RtpReceiverState RtpTransceiverState::MoveReceiverState() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  base::Optional<RtpReceiverState> temp(base::nullopt);
+  base::Optional<blink::RtpReceiverState> temp(base::nullopt);
   receiver_state_.swap(temp);
   return *std::move(temp);
 }
@@ -188,8 +188,8 @@ class RTCRtpTransceiver::RTCRtpTransceiverInternal
         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());
+    receiver_ = std::make_unique<blink::RTCRtpReceiverImpl>(
+        native_peer_connection, state_.MoveReceiverState());
   }
 
   const RtpTransceiverState& state() const {
@@ -227,7 +227,7 @@ class RTCRtpTransceiver::RTCRtpTransceiverInternal
     return sender_.get();
   }
 
-  RTCRtpReceiver* content_receiver() {
+  blink::RTCRtpReceiverImpl* content_receiver() {
     DCHECK(main_task_runner_->BelongsToCurrentThread());
     return receiver_.get();
   }
@@ -261,7 +261,7 @@ class RTCRtpTransceiver::RTCRtpTransceiverInternal
   const scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver_;
   RtpTransceiverState state_;
   std::unique_ptr<RTCRtpSender> sender_;
-  std::unique_ptr<RTCRtpReceiver> receiver_;
+  std::unique_ptr<blink::RTCRtpReceiverImpl> receiver_;
 };
 
 struct RTCRtpTransceiver::RTCRtpTransceiverInternalTraits {
@@ -320,7 +320,7 @@ RTCRtpSender* RTCRtpTransceiver::content_sender() {
   return internal_->content_sender();
 }
 
-RTCRtpReceiver* RTCRtpTransceiver::content_receiver() {
+blink::RTCRtpReceiverImpl* RTCRtpTransceiver::content_receiver() {
   return internal_->content_receiver();
 }
 

content/renderer/media/webrtc/rtc_rtp_transceiver.h

@@ -8,9 +8,9 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/optional.h"
 #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 "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/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/webrtc/api/rtp_transceiver_interface.h"
 
@@ -59,7 +59,7 @@ class CONTENT_EXPORT RtpTransceiverState {
       scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
       scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver,
       base::Optional<RtpSenderState> sender_state,
-      base::Optional<RtpReceiverState> receiver_state,
+      base::Optional<blink::RtpReceiverState> receiver_state,
       base::Optional<std::string> mid,
       bool stopped,
       webrtc::RtpTransceiverDirection direction,
@@ -83,8 +83,8 @@ class CONTENT_EXPORT RtpTransceiverState {
   scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver() const;
   const base::Optional<RtpSenderState>& sender_state() const;
   RtpSenderState MoveSenderState();
-  const base::Optional<RtpReceiverState>& receiver_state() const;
-  RtpReceiverState MoveReceiverState();
+  const base::Optional<blink::RtpReceiverState>& receiver_state() const;
+  blink::RtpReceiverState MoveReceiverState();
   base::Optional<std::string> mid() const;
   bool stopped() const;
   webrtc::RtpTransceiverDirection direction() const;
@@ -98,7 +98,7 @@ class CONTENT_EXPORT RtpTransceiverState {
   scoped_refptr<webrtc::RtpTransceiverInterface> webrtc_transceiver_;
   bool is_initialized_;
   base::Optional<RtpSenderState> sender_state_;
-  base::Optional<RtpReceiverState> receiver_state_;
+  base::Optional<blink::RtpReceiverState> receiver_state_;
   base::Optional<std::string> mid_;
   bool stopped_;
   webrtc::RtpTransceiverDirection direction_;
@@ -163,7 +163,7 @@ class CONTENT_EXPORT RTCRtpTransceiver : public blink::WebRTCRtpTransceiver {
   void set_state(RtpTransceiverState state,
                  TransceiverStateUpdateMode update_mode);
   RTCRtpSender* content_sender();
-  RTCRtpReceiver* content_receiver();
+  blink::RTCRtpReceiverImpl* content_receiver();
 
   blink::WebRTCRtpTransceiverImplementationType ImplementationType()
       const override;

content/renderer/media/webrtc/rtc_rtp_transceiver_unittest.cc

@@ -139,10 +139,10 @@ class RTCRtpTransceiverTest : public ::testing::Test {
                        webrtc_transceiver->sender().get(),
                        std::move(sender_track_ref),
                        webrtc_transceiver->sender()->stream_ids()),
-        RtpReceiverState(main_task_runner_, signaling_task_runner(),
-                         webrtc_transceiver->receiver().get(),
-                         std::move(receiver_track_ref),
-                         std::move(receiver_stream_ids)),
+        blink::RtpReceiverState(main_task_runner_, signaling_task_runner(),
+                                webrtc_transceiver->receiver().get(),
+                                std::move(receiver_track_ref),
+                                std::move(receiver_stream_ids)),
         blink::ToBaseOptional(webrtc_transceiver->mid()),
         webrtc_transceiver->stopped(), webrtc_transceiver->direction(),
         blink::ToBaseOptional(webrtc_transceiver->current_direction()),

content/renderer/media/webrtc/transceiver_state_surfacer.cc

@@ -96,7 +96,7 @@ void TransceiverStateSurfacer::Initialize(
           std::move(sender_track_ref), webrtc_sender->stream_ids());
     }
     // Create the receiver state.
-    base::Optional<RtpReceiverState> receiver_state;
+    base::Optional<blink::RtpReceiverState> receiver_state;
     auto webrtc_receiver = webrtc_transceiver->receiver();
     if (webrtc_receiver) {
       DCHECK(webrtc_receiver->track());
@@ -108,7 +108,7 @@ void TransceiverStateSurfacer::Initialize(
       for (auto& stream : webrtc_receiver->streams()) {
         receiver_stream_ids.push_back(stream->id());
       }
-      receiver_state = RtpReceiverState(
+      receiver_state = blink::RtpReceiverState(
           main_task_runner_, signaling_task_runner_, webrtc_receiver.get(),
           std::move(receiver_track_ref), std::move(receiver_stream_ids));
     }

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_receiver.h"
 #include "content/renderer/media/webrtc/rtc_rtp_sender.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/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/webrtc/api/jsep.h"
 #include "third_party/webrtc/api/peer_connection_interface.h"

content/renderer/media/webrtc/webrtc_set_description_observer_unittest.cc

@@ -319,7 +319,7 @@ class WebRtcSetDescriptionObserverHandlerTest
     EXPECT_EQ(sender->stream_ids(), sender_state.stream_ids());
     // Inspect receiver states.
     EXPECT_TRUE(transceiver_state.receiver_state());
-    const RtpReceiverState& receiver_state =
+    const blink::RtpReceiverState& receiver_state =
         *transceiver_state.receiver_state();
     EXPECT_TRUE(receiver_state.is_initialized());
     EXPECT_EQ(receiver.get(), receiver_state.webrtc_receiver());
@@ -353,7 +353,7 @@ class WebRtcSetDescriptionObserverHandlerTest
         observer_->states().transceiver_states[0];
     EXPECT_FALSE(transceiver_state.sender_state());
     EXPECT_TRUE(transceiver_state.receiver_state());
-    const RtpReceiverState& receiver_state =
+    const blink::RtpReceiverState& receiver_state =
         *transceiver_state.receiver_state();
     EXPECT_TRUE(receiver_state.is_initialized());
     EXPECT_EQ(receiver.get(), receiver_state.webrtc_receiver());

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_receiver_unittest.cc",
     "../renderer/media/webrtc/rtc_rtp_sender_unittest.cc",
     "../renderer/media/webrtc/rtc_rtp_transceiver_unittest.cc",
     "../renderer/media/webrtc/task_queue_factory_unittest.cc",

third_party/blink/public/BUILD.gn

@@ -386,6 +386,7 @@ source_set("blink_headers") {
     "web/modules/peerconnection/media_stream_remote_video_source.h",
     "web/modules/peerconnection/media_stream_video_webrtc_sink.h",
     "web/modules/peerconnection/peer_connection_dependency_factory.h",
+    "web/modules/peerconnection/rtc_rtp_receiver_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_receiver.h → third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_impl.h

@@ -2,15 +2,15 @@
 // 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_RECEIVER_H_
-#define CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_RECEIVER_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_PEERCONNECTION_RTC_RTP_RECEIVER_IMPL_H_
+#define THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_PEERCONNECTION_RTC_RTP_RECEIVER_IMPL_H_
 
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.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_media_stream.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_receiver.h"
@@ -22,7 +22,7 @@
 #include "third_party/webrtc/api/rtp_receiver_interface.h"
 #include "third_party/webrtc/api/stats/rtc_stats.h"
 
-namespace content {
+namespace blink {
 
 // This class represents the state of a receiver; a snapshot of what a
 // webrtc-layer receiver looked like when it was inspected on the signaling
@@ -55,10 +55,12 @@ namespace content {
 // Except for initialization logic and operator=(), the RtpReceiverState is
 // immutable and only accessible on the main thread.
 //
-// TODO(hbos): [Onion Soup] When the sender implementation is moved to blink
-// this will be part of the blink sender instead of the content sender.
-// https://crbug.com/787254
-class CONTENT_EXPORT RtpReceiverState {
+// TODO(crbug.com/787254): Move the classes below out of the Blink exposed API.
+// Also, consider merging RTCRtpReceiverImpl and RTCRtpReceiver, and removing
+// WebRTCRtpReceiver when all its clients are Onion soup'ed.
+//
+// Last, move away from using std::vector.
+class BLINK_MODULES_EXPORT RtpReceiverState {
  public:
   RtpReceiverState(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
@@ -104,20 +106,21 @@ class CONTENT_EXPORT RtpReceiverState {
 };
 
 // Used to surface |webrtc::RtpReceiverInterface| to blink. Multiple
-// |RTCRtpReceiver|s could reference the same webrtc receiver; |id| is the value
-// of the pointer to the webrtc receiver.
-class CONTENT_EXPORT RTCRtpReceiver : public blink::WebRTCRtpReceiver {
+// |RTCRtpReceiverImpl|s could reference the same webrtc receiver; |id| is the
+// value of the pointer to the webrtc receiver.
+class BLINK_MODULES_EXPORT RTCRtpReceiverImpl
+    : public blink::WebRTCRtpReceiver {
  public:
   static uintptr_t getId(
       const webrtc::RtpReceiverInterface* webrtc_rtp_receiver);
 
-  RTCRtpReceiver(
+  RTCRtpReceiverImpl(
       scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
       RtpReceiverState state);
-  RTCRtpReceiver(const RTCRtpReceiver& other);
-  ~RTCRtpReceiver() override;
+  RTCRtpReceiverImpl(const RTCRtpReceiverImpl& other);
+  ~RTCRtpReceiverImpl() override;
 
-  RTCRtpReceiver& operator=(const RTCRtpReceiver& other);
+  RTCRtpReceiverImpl& operator=(const RTCRtpReceiverImpl& other);
 
   const RtpReceiverState& state() const;
   void set_state(RtpReceiverState state);
@@ -144,7 +147,7 @@ class CONTENT_EXPORT RTCRtpReceiver : public blink::WebRTCRtpReceiver {
   scoped_refptr<RTCRtpReceiverInternal> internal_;
 };
 
-class CONTENT_EXPORT RTCRtpReceiverOnlyTransceiver
+class BLINK_MODULES_EXPORT RTCRtpReceiverOnlyTransceiver
     : public blink::WebRTCRtpTransceiver {
  public:
   RTCRtpReceiverOnlyTransceiver(
@@ -171,6 +174,6 @@ class CONTENT_EXPORT RTCRtpReceiverOnlyTransceiver
   std::unique_ptr<blink::WebRTCRtpReceiver> receiver_;
 };
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_RECEIVER_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_WEB_MODULES_PEERCONNECTION_RTC_RTP_RECEIVER_IMPL_H_

third_party/blink/renderer/modules/BUILD.gn

@@ -390,6 +390,7 @@ jumbo_source_set("unit_tests") {
     "peerconnection/rtc_quic_stream_test.cc",
     "peerconnection/rtc_quic_transport_test.cc",
     "peerconnection/rtc_quic_transport_test.h",
+    "peerconnection/rtc_rtp_receiver_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

@@ -97,6 +97,7 @@ blink_modules_sources("peerconnection") {
     "rtc_quic_transport.h",
     "rtc_rtp_receiver.cc",
     "rtc_rtp_receiver.h",
+    "rtc_rtp_receiver_impl.cc",
     "rtc_rtp_sender.cc",
     "rtc_rtp_sender.h",
     "rtc_rtp_transceiver.cc",

content/renderer/media/webrtc/rtc_rtp_receiver.cc → third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver_impl.cc

@@ -2,16 +2,17 @@
 // 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_receiver.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "third_party/blink/public/platform/modules/peerconnection/webrtc_util.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_source.h"
 #include "third_party/blink/public/platform/web_rtc_stats.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 {
 
 RtpReceiverState::RtpReceiverState(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
@@ -126,10 +127,10 @@ const std::vector<std::string>& RtpReceiverState::stream_ids() const {
   return stream_ids_;
 }
 
-class RTCRtpReceiver::RTCRtpReceiverInternal
-    : public base::RefCountedThreadSafe<
-          RTCRtpReceiver::RTCRtpReceiverInternal,
-          RTCRtpReceiver::RTCRtpReceiverInternalTraits> {
+class RTCRtpReceiverImpl::RTCRtpReceiverInternal
+    : public WTF::ThreadSafeRefCounted<
+          RTCRtpReceiverImpl::RTCRtpReceiverInternal,
+          RTCRtpReceiverImpl::RTCRtpReceiverInternalTraits> {
  public:
   RTCRtpReceiverInternal(
       scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
@@ -189,7 +190,9 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
   }
 
  private:
-  friend struct RTCRtpReceiver::RTCRtpReceiverInternalTraits;
+  friend class WTF::ThreadSafeRefCounted<RTCRtpReceiverInternal,
+                                         RTCRtpReceiverInternalTraits>;
+  friend struct RTCRtpReceiverImpl::RTCRtpReceiverInternalTraits;
 
   ~RTCRtpReceiverInternal() {
     DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ -214,11 +217,7 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
   RtpReceiverState state_;
 };
 
-struct RTCRtpReceiver::RTCRtpReceiverInternalTraits {
- private:
-  friend class base::RefCountedThreadSafe<RTCRtpReceiverInternal,
-                                          RTCRtpReceiverInternalTraits>;
-
+struct RTCRtpReceiverImpl::RTCRtpReceiverInternalTraits {
   static void Destruct(const RTCRtpReceiverInternal* receiver) {
     // RTCRtpReceiverInternal owns AdapterRefs which have to be destroyed on the
     // main thread, this ensures delete always happens there.
@@ -226,7 +225,7 @@ struct RTCRtpReceiver::RTCRtpReceiverInternalTraits {
       receiver->main_task_runner_->PostTask(
           FROM_HERE,
           base::BindOnce(
-              &RTCRtpReceiver::RTCRtpReceiverInternalTraits::Destruct,
+              &RTCRtpReceiverImpl::RTCRtpReceiverInternalTraits::Destruct,
               base::Unretained(receiver)));
       return;
     }
@@ -234,57 +233,61 @@ struct RTCRtpReceiver::RTCRtpReceiverInternalTraits {
   }
 };
 
-uintptr_t RTCRtpReceiver::getId(
+uintptr_t RTCRtpReceiverImpl::getId(
     const webrtc::RtpReceiverInterface* webrtc_rtp_receiver) {
   return reinterpret_cast<uintptr_t>(webrtc_rtp_receiver);
 }
 
-RTCRtpReceiver::RTCRtpReceiver(
+RTCRtpReceiverImpl::RTCRtpReceiverImpl(
     scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
     RtpReceiverState state)
-    : internal_(new RTCRtpReceiverInternal(std::move(native_peer_connection),
-                                           std::move(state))) {}
+    : internal_(base::MakeRefCounted<RTCRtpReceiverInternal>(
+          std::move(native_peer_connection),
+          std::move(state))) {}
 
-RTCRtpReceiver::RTCRtpReceiver(const RTCRtpReceiver& other)
+RTCRtpReceiverImpl::RTCRtpReceiverImpl(const RTCRtpReceiverImpl& other)
     : internal_(other.internal_) {}
 
-RTCRtpReceiver::~RTCRtpReceiver() {}
+RTCRtpReceiverImpl::~RTCRtpReceiverImpl() {}
 
-RTCRtpReceiver& RTCRtpReceiver::operator=(const RTCRtpReceiver& other) {
+RTCRtpReceiverImpl& RTCRtpReceiverImpl::operator=(
+    const RTCRtpReceiverImpl& other) {
   internal_ = other.internal_;
   return *this;
 }
 
-const RtpReceiverState& RTCRtpReceiver::state() const {
+const RtpReceiverState& RTCRtpReceiverImpl::state() const {
   return internal_->state();
 }
 
-void RTCRtpReceiver::set_state(RtpReceiverState state) {
+void RTCRtpReceiverImpl::set_state(RtpReceiverState state) {
   internal_->set_state(std::move(state));
 }
 
-std::unique_ptr<blink::WebRTCRtpReceiver> RTCRtpReceiver::ShallowCopy() const {
-  return std::make_unique<RTCRtpReceiver>(*this);
+std::unique_ptr<blink::WebRTCRtpReceiver> RTCRtpReceiverImpl::ShallowCopy()
+    const {
+  return std::make_unique<RTCRtpReceiverImpl>(*this);
 }
 
-uintptr_t RTCRtpReceiver::Id() const {
+uintptr_t RTCRtpReceiverImpl::Id() const {
   return getId(internal_->state().webrtc_receiver().get());
 }
 
 rtc::scoped_refptr<webrtc::DtlsTransportInterface>
-RTCRtpReceiver::DtlsTransport() {
+RTCRtpReceiverImpl::DtlsTransport() {
   return internal_->state().webrtc_dtls_transport();
 }
 
-webrtc::DtlsTransportInformation RTCRtpReceiver::DtlsTransportInformation() {
+webrtc::DtlsTransportInformation
+RTCRtpReceiverImpl::DtlsTransportInformation() {
   return internal_->state().webrtc_dtls_transport_information();
 }
 
-const blink::WebMediaStreamTrack& RTCRtpReceiver::Track() const {
+const blink::WebMediaStreamTrack& RTCRtpReceiverImpl::Track() const {
   return internal_->state().track_ref()->web_track();
 }
 
-blink::WebVector<blink::WebString> RTCRtpReceiver::StreamIds() const {
+blink::WebVector<blink::WebString> RTCRtpReceiverImpl::StreamIds() const {
   const auto& stream_ids = internal_->state().stream_ids();
   blink::WebVector<blink::WebString> web_stream_ids(stream_ids.size());
   for (size_t i = 0; i < stream_ids.size(); ++i)
@@ -293,21 +296,22 @@ blink::WebVector<blink::WebString> RTCRtpReceiver::StreamIds() const {
 }
 
 blink::WebVector<std::unique_ptr<blink::WebRTCRtpSource>>
-RTCRtpReceiver::GetSources() {
+RTCRtpReceiverImpl::GetSources() {
   return internal_->GetSources();
 }
 
-void RTCRtpReceiver::GetStats(
+void RTCRtpReceiverImpl::GetStats(
     blink::WebRTCStatsReportCallback callback,
     const blink::WebVector<webrtc::NonStandardGroupId>& exposed_group_ids) {
   internal_->GetStats(std::move(callback), exposed_group_ids);
 }
 
-std::unique_ptr<webrtc::RtpParameters> RTCRtpReceiver::GetParameters() const {
+std::unique_ptr<webrtc::RtpParameters> RTCRtpReceiverImpl::GetParameters()
+    const {
   return internal_->GetParameters();
 }
 
-void RTCRtpReceiver::SetJitterBufferMinimumDelay(
+void RTCRtpReceiverImpl::SetJitterBufferMinimumDelay(
     base::Optional<double> delay_seconds) {
   internal_->SetJitterBufferMinimumDelay(delay_seconds);
 }
@@ -379,4 +383,4 @@ webrtc::RTCError RTCRtpReceiverOnlyTransceiver::SetCodecPreferences(
   NOTIMPLEMENTED();
   return {};
 }
-}  // namespace content
+}  // namespace blink

content/renderer/media/webrtc/rtc_rtp_receiver_unittest.cc → third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver_impl_test.cc

@@ -2,18 +2,16 @@
 // 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_receiver.h"
+#include "third_party/blink/public/web/modules/peerconnection/rtc_rtp_receiver_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/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/task_environment.h"
-#include "content/child/child_process.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_rtc_stats.h"
@@ -23,13 +21,14 @@
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
 #include "third_party/blink/public/web/modules/peerconnection/webrtc_stats_report_obtainer.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/stats/rtc_stats_report.h"
 #include "third_party/webrtc/api/stats/rtcstats_objects.h"
 #include "third_party/webrtc/api/test/mock_rtpreceiver.h"
 
-namespace content {
+namespace blink {
 
-class RTCRtpReceiverTest : public ::testing::Test {
+class RTCRtpReceiverImplTest : public ::testing::Test {
  public:
   void SetUp() override {
     dependency_factory_.reset(new blink::MockPeerConnectionDependencyFactory());
@@ -59,26 +58,26 @@ class RTCRtpReceiverTest : public ::testing::Test {
     run_loop.Run();
   }
 
-  std::unique_ptr<RTCRtpReceiver> CreateReceiver(
+  std::unique_ptr<RTCRtpReceiverImpl> CreateReceiver(
       scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track) {
     std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
         track_ref;
     base::RunLoop run_loop;
     dependency_factory_->GetWebRtcSignalingThread()->PostTask(
         FROM_HERE,
-        base::BindOnce(&RTCRtpReceiverTest::CreateReceiverOnSignalingThread,
+        base::BindOnce(&RTCRtpReceiverImplTest::CreateReceiverOnSignalingThread,
                        base::Unretained(this), std::move(webrtc_track),
                        base::Unretained(&track_ref),
                        base::Unretained(&run_loop)));
     run_loop.Run();
     DCHECK(mock_webrtc_receiver_);
     DCHECK(track_ref);
-    RtpReceiverState state(
+    blink::RtpReceiverState state(
         main_thread_, dependency_factory_->GetWebRtcSignalingThread(),
         mock_webrtc_receiver_.get(), std::move(track_ref), {});
     state.Initialize();
-    return std::make_unique<RTCRtpReceiver>(peer_connection_.get(),
-                                            std::move(state));
+    return std::make_unique<RTCRtpReceiverImpl>(peer_connection_.get(),
+                                                std::move(state));
   }
 
   scoped_refptr<blink::WebRTCStatsReportObtainer> GetStats() {
@@ -100,11 +99,7 @@ class RTCRtpReceiverTest : public ::testing::Test {
     run_loop->Quit();
   }
 
-  // Code under test expects to be run in a process with an initialized
-  // ChildProcess, which requires ThreadPool, and a main-thread MessageLoop,
-  // which the TaskEnvironment also provides.
-  base::test::TaskEnvironment task_environment_;
-  ChildProcess child_process_;
+  ScopedTestingPlatformSupport<IOTaskRunnerTestingPlatformSupport> platform_;
 
   std::unique_ptr<blink::MockPeerConnectionDependencyFactory>
       dependency_factory_;
@@ -112,10 +107,10 @@ class RTCRtpReceiverTest : public ::testing::Test {
   scoped_refptr<blink::WebRtcMediaStreamTrackAdapterMap> track_map_;
   rtc::scoped_refptr<blink::MockPeerConnectionImpl> peer_connection_;
   rtc::scoped_refptr<webrtc::MockRtpReceiver> mock_webrtc_receiver_;
-  std::unique_ptr<RTCRtpReceiver> receiver_;
+  std::unique_ptr<RTCRtpReceiverImpl> receiver_;
 };
 
-TEST_F(RTCRtpReceiverTest, CreateReceiver) {
+TEST_F(RTCRtpReceiverImplTest, CreateReceiver) {
   scoped_refptr<blink::MockWebRtcAudioTrack> webrtc_track =
       blink::MockWebRtcAudioTrack::Create("webrtc_track");
   receiver_ = CreateReceiver(webrtc_track);
@@ -124,11 +119,11 @@ TEST_F(RTCRtpReceiverTest, CreateReceiver) {
   EXPECT_EQ(receiver_->state().track_ref()->webrtc_track(), webrtc_track);
 }
 
-TEST_F(RTCRtpReceiverTest, ShallowCopy) {
+TEST_F(RTCRtpReceiverImplTest, ShallowCopy) {
   scoped_refptr<blink::MockWebRtcAudioTrack> webrtc_track =
       blink::MockWebRtcAudioTrack::Create("webrtc_track");
   receiver_ = CreateReceiver(webrtc_track);
-  auto copy = std::make_unique<RTCRtpReceiver>(*receiver_);
+  auto copy = std::make_unique<RTCRtpReceiverImpl>(*receiver_);
   EXPECT_EQ(receiver_->state().track_ref()->webrtc_track(), webrtc_track);
   const auto& webrtc_receiver = receiver_->state().webrtc_receiver();
   auto web_track_unique_id = receiver_->Track().UniqueId();
@@ -143,7 +138,7 @@ TEST_F(RTCRtpReceiverTest, ShallowCopy) {
   EXPECT_EQ(copy->Track().UniqueId(), web_track_unique_id);
 }
 
-TEST_F(RTCRtpReceiverTest, GetStats) {
+TEST_F(RTCRtpReceiverImplTest, GetStats) {
   scoped_refptr<blink::MockWebRtcAudioTrack> webrtc_track =
       blink::MockWebRtcAudioTrack::Create("webrtc_track");
   receiver_ = CreateReceiver(webrtc_track);
@@ -170,4 +165,4 @@ TEST_F(RTCRtpReceiverTest, GetStats) {
   EXPECT_EQ(stats->Timestamp(), 1.234);
 }
 
-}  // namespace content
+}  // namespace blink