Commit da339d4b authored by Antonio Gomes's avatar Antonio Gomes Committed by Commit Bot

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: default avatarGuido Urdaneta <guidou@chromium.org>
Reviewed-by: default avatarKentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704969}
parent dfeceab4
......@@ -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",
......
......@@ -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;
......
......@@ -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;
}
......
......@@ -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_;
......
......@@ -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();
}
......
......@@ -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;
......
......@@ -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()),
......
......@@ -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));
}
......
......@@ -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"
......
......@@ -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());
......
......@@ -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",
......
......@@ -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",
......
......@@ -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_
......@@ -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",
......
......@@ -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",
......
......@@ -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
......@@ -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
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment