1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
// Copyright (c) 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_RTC_RTP_SENDER_IMPL_H_
#define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_RTC_RTP_SENDER_IMPL_H_
#include <memory>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/single_thread_task_runner.h"
#include "third_party/blink/public/platform/web_media_stream_track.h"
#include "third_party/blink/renderer/modules/modules_export.h"
#include "third_party/blink/renderer/modules/peerconnection/webrtc_media_stream_track_adapter_map.h"
#include "third_party/blink/renderer/platform/peerconnection/rtc_rtp_sender_platform.h"
#include "third_party/blink/renderer/platform/peerconnection/rtc_rtp_transceiver_platform.h"
#include "third_party/blink/renderer/platform/peerconnection/rtc_stats.h"
#include "third_party/webrtc/api/peer_connection_interface.h"
#include "third_party/webrtc/api/rtp_sender_interface.h"
#include "third_party/webrtc/api/scoped_refptr.h"
namespace blink {
class RTCEncodedAudioStreamTransformer;
class RTCEncodedVideoStreamTransformer;
// This class represents the state of a sender; a snapshot of what a
// webrtc-layer sender looked like when it was inspected on the signaling thread
// such that this information can be moved to the main thread in a single
// PostTask. It is used to surface state changes to make the blink-layer sender
// up-to-date.
//
// Blink objects live on the main thread and webrtc objects live on the
// signaling thread. If multiple asynchronous operations begin execution on the
// main thread they are posted and executed in order on the signaling thread.
// For example, operation A and operation B are called in JavaScript. When A is
// done on the signaling thread, webrtc object states will be updated. A
// callback is posted to the main thread so that blink objects can be updated to
// match the result of operation A. But if callback A tries to inspect the
// webrtc objects from the main thread this requires posting back to the
// signaling thread and waiting, which also includes waiting for the previously
// posted task: operation B. Inspecting the webrtc object like this does not
// guarantee you to get the state of operation A.
//
// As such, all state changes associated with an operation have to be surfaced
// in the same callback. This includes copying any states into a separate object
// so that it can be inspected on the main thread without any additional thread
// hops.
//
// The RtpSenderState is a snapshot of what the webrtc::RtpSenderInterface
// looked like when the RtpSenderState was created on the signaling thread. It
// also takes care of initializing track adapters, such that we have access to a
// blink track corresponding to the webrtc track of the sender.
//
// Except for initialization logic and operator=(), the RtpSenderState is
// immutable and only accessible on the main thread.
//
// TODO(crbug.com/787254): Consider merging RTCRtpSenderImpl and RTCRtpReceiver,
// and removing RTCRtpSenderPlatform when all its clients are Onion soup'ed.
// Also, move away from using std::vector.
class MODULES_EXPORT RtpSenderState {
public:
RtpSenderState(
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
scoped_refptr<webrtc::RtpSenderInterface> webrtc_sender,
std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
track_ref,
std::vector<std::string> stream_ids);
RtpSenderState(RtpSenderState&&);
RtpSenderState(const RtpSenderState&) = delete;
~RtpSenderState();
// This is intended to be used for moving the object from the signaling thread
// to the main thread and as such has no thread checks. Once moved to the main
// this should only be invoked on the main thread.
RtpSenderState& operator=(RtpSenderState&&);
RtpSenderState& operator=(const RtpSenderState&) = delete;
bool is_initialized() const;
void Initialize();
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner() const;
scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner() const;
scoped_refptr<webrtc::RtpSenderInterface> webrtc_sender() const;
rtc::scoped_refptr<webrtc::DtlsTransportInterface> webrtc_dtls_transport()
const;
webrtc::DtlsTransportInformation webrtc_dtls_transport_information() const;
const std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>&
track_ref() const;
void set_track_ref(
std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
track_ref);
std::vector<std::string> stream_ids() const;
private:
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner_;
scoped_refptr<webrtc::RtpSenderInterface> webrtc_sender_;
rtc::scoped_refptr<webrtc::DtlsTransportInterface> webrtc_dtls_transport_;
webrtc::DtlsTransportInformation webrtc_dtls_transport_information_;
bool is_initialized_;
std::unique_ptr<blink::WebRtcMediaStreamTrackAdapterMap::AdapterRef>
track_ref_;
std::vector<std::string> stream_ids_;
};
// Used to surface |webrtc::RtpSenderInterface| to blink. Multiple
// |RTCRtpSenderImpl|s could reference the same webrtc sender; |id| is the value
// of the pointer to the webrtc sender.
// TODO(hbos): [Onion Soup] Move all of the implementation inside the blink
// object and remove this class and interface. The blink object is reference
// counted and we can get rid of this "Web"-copyable with "internal" nonsense,
// all the blink object will need is the RtpSenderState. Requires coordination
// with transceivers and receivers since these are tightly coupled.
// https://crbug.com/787254
class MODULES_EXPORT RTCRtpSenderImpl : public blink::RTCRtpSenderPlatform {
public:
static uintptr_t getId(const webrtc::RtpSenderInterface* webrtc_sender);
RTCRtpSenderImpl(
scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
scoped_refptr<blink::WebRtcMediaStreamTrackAdapterMap> track_map,
RtpSenderState state,
bool force_encoded_audio_insertable_streams,
bool force_encoded_video_insertable_streams);
RTCRtpSenderImpl(const RTCRtpSenderImpl& other);
~RTCRtpSenderImpl() override;
RTCRtpSenderImpl& operator=(const RTCRtpSenderImpl& other);
const RtpSenderState& state() const;
void set_state(RtpSenderState state);
// blink::RTCRtpSenderPlatform.
std::unique_ptr<blink::RTCRtpSenderPlatform> ShallowCopy() const override;
uintptr_t Id() const override;
rtc::scoped_refptr<webrtc::DtlsTransportInterface> DtlsTransport() override;
webrtc::DtlsTransportInformation DtlsTransportInformation() override;
MediaStreamComponent* Track() const override;
Vector<String> StreamIds() const override;
void ReplaceTrack(MediaStreamComponent* with_track,
RTCVoidRequest* request) override;
std::unique_ptr<blink::RtcDtmfSenderHandler> GetDtmfSender() const override;
std::unique_ptr<webrtc::RtpParameters> GetParameters() const override;
void SetParameters(Vector<webrtc::RtpEncodingParameters>,
absl::optional<webrtc::DegradationPreference>,
blink::RTCVoidRequest*) override;
void GetStats(RTCStatsReportCallback,
const Vector<webrtc::NonStandardGroupId>&) override;
void SetStreams(const Vector<String>& stream_ids) override;
RTCEncodedAudioStreamTransformer* GetEncodedAudioStreamTransformer()
const override;
RTCEncodedVideoStreamTransformer* GetEncodedVideoStreamTransformer()
const override;
// The ReplaceTrack() that takes a blink::RTCVoidRequest is implemented on
// top of this, which returns the result in a callback instead. Allows doing
// ReplaceTrack() without having a blink::RTCVoidRequest, which can only be
// constructed inside of blink.
void ReplaceTrack(MediaStreamComponent* with_track,
base::OnceCallback<void(bool)> callback);
bool RemoveFromPeerConnection(webrtc::PeerConnectionInterface* pc);
private:
class RTCRtpSenderInternal;
struct RTCRtpSenderInternalTraits;
scoped_refptr<RTCRtpSenderInternal> internal_;
};
class MODULES_EXPORT RTCRtpSenderOnlyTransceiver
: public RTCRtpTransceiverPlatform {
public:
explicit RTCRtpSenderOnlyTransceiver(
std::unique_ptr<blink::RTCRtpSenderPlatform> sender);
~RTCRtpSenderOnlyTransceiver() override;
RTCRtpTransceiverPlatformImplementationType ImplementationType()
const override;
uintptr_t Id() const override;
String Mid() const override;
std::unique_ptr<RTCRtpSenderPlatform> Sender() const override;
std::unique_ptr<RTCRtpReceiverPlatform> Receiver() const override;
bool Stopped() const override;
webrtc::RtpTransceiverDirection Direction() const override;
void SetDirection(webrtc::RtpTransceiverDirection direction) override;
base::Optional<webrtc::RtpTransceiverDirection> CurrentDirection()
const override;
base::Optional<webrtc::RtpTransceiverDirection> FiredDirection()
const override;
webrtc::RTCError SetCodecPreferences(
Vector<webrtc::RtpCodecCapability>) override;
private:
std::unique_ptr<blink::RTCRtpSenderPlatform> sender_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_RTC_RTP_SENDER_IMPL_H_
|
