Thanks to visit codestin.com
Credit goes to webrtc.googlesource.com

Google Git
Sign in
webrtc / src / refs/heads/lkgr / . / pc / peer_connection_wrapper.cc
blob: 3c21208844556760ac4cf2937d5442c8a472690c [file] [log] [blame]
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]1/*
2 * Copyright 2017 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]11#include "pc/peer_connection_wrapper.h"
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]12
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]13#include <memory>
Florent Castelli8037fc62024-08-29 13:00:40[diff] [blame]14#include <optional>
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]15#include <string>
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]16#include <utility>
Steve Anton36b29d12017-10-30 16:57:42[diff] [blame]17#include <vector>
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]18
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]19#include "api/data_channel_interface.h"
Artem Titov741daaf2019-03-21 13:37:36[diff] [blame]20#include "api/function_view.h"
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]21#include "api/jsep.h"
22#include "api/make_ref_counted.h"
23#include "api/media_stream_interface.h"
24#include "api/media_types.h"
25#include "api/peer_connection_interface.h"
26#include "api/rtc_error.h"
27#include "api/rtp_parameters.h"
28#include "api/rtp_sender_interface.h"
29#include "api/rtp_transceiver_interface.h"
30#include "api/scoped_refptr.h"
31#include "api/stats/rtc_stats_report.h"
32#include "api/test/rtc_error_matchers.h"
Danil Chapovalovb1ec8132025-02-04 16:50:44[diff] [blame]33#include "pc/peer_connection.h"
34#include "pc/peer_connection_proxy.h"
Steve Anton10542f22019-01-11 17:11:00[diff] [blame]35#include "pc/test/fake_video_track_source.h"
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]36#include "pc/test/mock_peer_connection_observers.h"
Yves Gerey3e707812018-11-28 15:47:49[diff] [blame]37#include "rtc_base/checks.h"
Yves Gerey3e707812018-11-28 15:47:49[diff] [blame]38#include "rtc_base/logging.h"
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]39#include "test/gmock.h"
Yves Gerey3e707812018-11-28 15:47:49[diff] [blame]40#include "test/gtest.h"
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]41#include "test/wait_until.h"
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]42
43namespace webrtc {
44
Philipp Hanckecfaba8f2025-01-15 01:16:39[diff] [blame]45using ::testing::Eq;
Steve Anton22da89f2018-01-25 21:58:07[diff] [blame]46using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
47
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]48PeerConnectionWrapper::PeerConnectionWrapper(
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]49 scoped_refptr<PeerConnectionFactoryInterface> pc_factory,
50 scoped_refptr<PeerConnectionInterface> pc,
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]51 std::unique_ptr<MockPeerConnectionObserver> observer)
Mirko Bonadei2a823102017-11-13 10:50:33[diff] [blame]52 : pc_factory_(std::move(pc_factory)),
53 observer_(std::move(observer)),
54 pc_(std::move(pc)) {
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]55 RTC_DCHECK(pc_factory_);
56 RTC_DCHECK(pc_);
57 RTC_DCHECK(observer_);
58 observer_->SetPeerConnectionInterface(pc_.get());
59}
60
Tomas Gunnarsson2efb8a52021-04-01 14:26:57[diff] [blame]61PeerConnectionWrapper::~PeerConnectionWrapper() {
62 if (pc_)
63 pc_->Close();
64}
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]65
66PeerConnectionFactoryInterface* PeerConnectionWrapper::pc_factory() {
67 return pc_factory_.get();
68}
69
70PeerConnectionInterface* PeerConnectionWrapper::pc() {
71 return pc_.get();
72}
73
74MockPeerConnectionObserver* PeerConnectionWrapper::observer() {
75 return observer_.get();
76}
77
Danil Chapovalovb1ec8132025-02-04 16:50:44[diff] [blame]78PeerConnection* PeerConnectionWrapper::GetInternalPeerConnection() {
79 auto* pci =
80 static_cast<PeerConnectionProxyWithInternal<PeerConnectionInterface>*>(
81 pc());
82 return static_cast<PeerConnection*>(pci->internal());
83}
84
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]85std::unique_ptr<SessionDescriptionInterface>
86PeerConnectionWrapper::CreateOffer() {
Steve Anton22da89f2018-01-25 21:58:07[diff] [blame]87 return CreateOffer(RTCOfferAnswerOptions());
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]88}
89
90std::unique_ptr<SessionDescriptionInterface> PeerConnectionWrapper::CreateOffer(
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]91 const PeerConnectionInterface::RTCOfferAnswerOptions& options,
92 std::string* error_out) {
93 return CreateSdp(
94 [this, options](CreateSessionDescriptionObserver* observer) {
95 pc()->CreateOffer(observer, options);
96 },
97 error_out);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]98}
99
100std::unique_ptr<SessionDescriptionInterface>
101PeerConnectionWrapper::CreateOfferAndSetAsLocal() {
Steve Anton22da89f2018-01-25 21:58:07[diff] [blame]102 return CreateOfferAndSetAsLocal(RTCOfferAnswerOptions());
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]103}
104
105std::unique_ptr<SessionDescriptionInterface>
106PeerConnectionWrapper::CreateOfferAndSetAsLocal(
107 const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
Philipp Hancked72cc2f2025-07-01 18:24:07[diff] [blame]108 std::unique_ptr<SessionDescriptionInterface> offer = CreateOffer(options);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]109 if (!offer) {
110 return nullptr;
111 }
Harald Alvestrandf94ebc72025-10-08 12:31:10[diff] [blame]112 EXPECT_TRUE(SetLocalDescription(offer->Clone()));
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]113 return offer;
114}
115
116std::unique_ptr<SessionDescriptionInterface>
117PeerConnectionWrapper::CreateAnswer() {
Steve Anton22da89f2018-01-25 21:58:07[diff] [blame]118 return CreateAnswer(RTCOfferAnswerOptions());
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]119}
120
121std::unique_ptr<SessionDescriptionInterface>
122PeerConnectionWrapper::CreateAnswer(
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]123 const PeerConnectionInterface::RTCOfferAnswerOptions& options,
124 std::string* error_out) {
125 return CreateSdp(
126 [this, options](CreateSessionDescriptionObserver* observer) {
127 pc()->CreateAnswer(observer, options);
128 },
129 error_out);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]130}
131
132std::unique_ptr<SessionDescriptionInterface>
133PeerConnectionWrapper::CreateAnswerAndSetAsLocal() {
Steve Anton22da89f2018-01-25 21:58:07[diff] [blame]134 return CreateAnswerAndSetAsLocal(RTCOfferAnswerOptions());
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]135}
136
137std::unique_ptr<SessionDescriptionInterface>
138PeerConnectionWrapper::CreateAnswerAndSetAsLocal(
139 const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
Philipp Hancked72cc2f2025-07-01 18:24:07[diff] [blame]140 std::unique_ptr<SessionDescriptionInterface> answer = CreateAnswer(options);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]141 if (!answer) {
142 return nullptr;
143 }
Harald Alvestrandf94ebc72025-10-08 12:31:10[diff] [blame]144 EXPECT_TRUE(SetLocalDescription(answer->Clone()));
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]145 return answer;
146}
147
Eldar Rello5ab79e62019-10-09 15:29:44[diff] [blame]148std::unique_ptr<SessionDescriptionInterface>
149PeerConnectionWrapper::CreateRollback() {
Tommi7a191b12025-09-08 10:50:05[diff] [blame]150 return CreateRollbackSessionDescription();
Eldar Rello5ab79e62019-10-09 15:29:44[diff] [blame]151}
152
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]153std::unique_ptr<SessionDescriptionInterface> PeerConnectionWrapper::CreateSdp(
Evan Shrubsole97feff22025-03-12 09:13:45[diff] [blame]154 FunctionView<void(CreateSessionDescriptionObserver*)> fn,
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]155 std::string* error_out) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]156 auto observer = make_ref_counted<MockCreateSessionDescriptionObserver>();
Niels Möllerafb246b2022-04-20 12:26:50[diff] [blame]157 fn(observer.get());
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]158 EXPECT_THAT(
159 WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
160 IsRtcOk());
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]161 if (error_out && !observer->result()) {
162 *error_out = observer->error();
163 }
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]164 return observer->MoveDescription();
165}
166
167bool PeerConnectionWrapper::SetLocalDescription(
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]168 std::unique_ptr<SessionDescriptionInterface> desc,
169 std::string* error_out) {
170 return SetSdp(
171 [this, &desc](SetSessionDescriptionObserver* observer) {
172 pc()->SetLocalDescription(observer, desc.release());
173 },
174 error_out);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]175}
176
Philipp Hanckecfaba8f2025-01-15 01:16:39[diff] [blame]177bool PeerConnectionWrapper::SetLocalDescription(
178 std::unique_ptr<SessionDescriptionInterface> desc,
179 RTCError* error_out) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]180 auto observer = make_ref_counted<FakeSetLocalDescriptionObserver>();
Philipp Hanckecfaba8f2025-01-15 01:16:39[diff] [blame]181 pc()->SetLocalDescription(std::move(desc), observer);
182 EXPECT_THAT(
183 WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
184 IsRtcOk());
185 bool ok = observer->error().ok();
186 if (error_out)
187 *error_out = std::move(observer->error());
188 return ok;
189}
190
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]191bool PeerConnectionWrapper::SetRemoteDescription(
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]192 std::unique_ptr<SessionDescriptionInterface> desc,
193 std::string* error_out) {
194 return SetSdp(
195 [this, &desc](SetSessionDescriptionObserver* observer) {
196 pc()->SetRemoteDescription(observer, desc.release());
197 },
198 error_out);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]199}
200
Henrik Boström31638672017-11-23 16:48:32[diff] [blame]201bool PeerConnectionWrapper::SetRemoteDescription(
202 std::unique_ptr<SessionDescriptionInterface> desc,
203 RTCError* error_out) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]204 auto observer = make_ref_counted<FakeSetRemoteDescriptionObserver>();
Henrik Boström31638672017-11-23 16:48:32[diff] [blame]205 pc()->SetRemoteDescription(std::move(desc), observer);
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]206 EXPECT_THAT(
207 WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
208 IsRtcOk());
Henrik Boström31638672017-11-23 16:48:32[diff] [blame]209 bool ok = observer->error().ok();
210 if (error_out)
211 *error_out = std::move(observer->error());
212 return ok;
213}
214
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]215bool PeerConnectionWrapper::SetSdp(
Evan Shrubsole97feff22025-03-12 09:13:45[diff] [blame]216 FunctionView<void(SetSessionDescriptionObserver*)> fn,
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]217 std::string* error_out) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]218 auto observer = make_ref_counted<MockSetSessionDescriptionObserver>();
Niels Möllerafb246b2022-04-20 12:26:50[diff] [blame]219 fn(observer.get());
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]220 EXPECT_THAT(
221 WaitUntil([&] { return observer->called(); }, ::testing::IsTrue()),
222 IsRtcOk());
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]223 if (error_out && !observer->result()) {
224 *error_out = observer->error();
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]225 }
226 return observer->result();
227}
228
Steve Antondcc3c022017-12-23 00:02:54[diff] [blame]229bool PeerConnectionWrapper::ExchangeOfferAnswerWith(
230 PeerConnectionWrapper* answerer) {
Steve Anton22da89f2018-01-25 21:58:07[diff] [blame]231 return ExchangeOfferAnswerWith(answerer, RTCOfferAnswerOptions(),
232 RTCOfferAnswerOptions());
233}
234
235bool PeerConnectionWrapper::ExchangeOfferAnswerWith(
236 PeerConnectionWrapper* answerer,
237 const PeerConnectionInterface::RTCOfferAnswerOptions& offer_options,
238 const PeerConnectionInterface::RTCOfferAnswerOptions& answer_options) {
Steve Antondcc3c022017-12-23 00:02:54[diff] [blame]239 RTC_DCHECK(answerer);
240 if (answerer == this) {
241 RTC_LOG(LS_ERROR) << "Cannot exchange offer/answer with ourself!";
242 return false;
243 }
Philipp Hancked72cc2f2025-07-01 18:24:07[diff] [blame]244 std::unique_ptr<SessionDescriptionInterface> offer =
245 CreateOffer(offer_options);
Steve Antondcc3c022017-12-23 00:02:54[diff] [blame]246 EXPECT_TRUE(offer);
247 if (!offer) {
248 return false;
249 }
Harald Alvestrandf94ebc72025-10-08 12:31:10[diff] [blame]250 bool set_local_offer = SetLocalDescription(offer->Clone());
Steve Antondcc3c022017-12-23 00:02:54[diff] [blame]251 EXPECT_TRUE(set_local_offer);
252 if (!set_local_offer) {
253 return false;
254 }
255 bool set_remote_offer = answerer->SetRemoteDescription(std::move(offer));
256 EXPECT_TRUE(set_remote_offer);
257 if (!set_remote_offer) {
258 return false;
259 }
Philipp Hancked72cc2f2025-07-01 18:24:07[diff] [blame]260 std::unique_ptr<SessionDescriptionInterface> answer =
261 answerer->CreateAnswer(answer_options);
Steve Antondcc3c022017-12-23 00:02:54[diff] [blame]262 EXPECT_TRUE(answer);
263 if (!answer) {
264 return false;
265 }
Harald Alvestrandf94ebc72025-10-08 12:31:10[diff] [blame]266 bool set_local_answer = answerer->SetLocalDescription(answer->Clone());
Steve Antondcc3c022017-12-23 00:02:54[diff] [blame]267 EXPECT_TRUE(set_local_answer);
268 if (!set_local_answer) {
269 return false;
270 }
271 bool set_remote_answer = SetRemoteDescription(std::move(answer));
272 EXPECT_TRUE(set_remote_answer);
273 return set_remote_answer;
274}
275
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]276scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
Evan Shrubsole94adaee2025-05-09 10:35:15[diff] [blame]277 MediaType media_type) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]278 RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]279 pc()->AddTransceiver(media_type);
280 EXPECT_EQ(RTCErrorType::NONE, result.error().type());
281 return result.MoveValue();
282}
283
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]284scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
Evan Shrubsole94adaee2025-05-09 10:35:15[diff] [blame]285 MediaType media_type,
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]286 const RtpTransceiverInit& init) {
287 RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]288 pc()->AddTransceiver(media_type, init);
289 EXPECT_EQ(RTCErrorType::NONE, result.error().type());
290 return result.MoveValue();
291}
292
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]293scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
294 scoped_refptr<MediaStreamTrackInterface> track) {
295 RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]296 pc()->AddTransceiver(track);
297 EXPECT_EQ(RTCErrorType::NONE, result.error().type());
298 return result.MoveValue();
299}
300
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]301scoped_refptr<RtpTransceiverInterface> PeerConnectionWrapper::AddTransceiver(
302 scoped_refptr<MediaStreamTrackInterface> track,
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]303 const RtpTransceiverInit& init) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]304 RTCErrorOr<scoped_refptr<RtpTransceiverInterface>> result =
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]305 pc()->AddTransceiver(track, init);
306 EXPECT_EQ(RTCErrorType::NONE, result.error().type());
307 return result.MoveValue();
308}
309
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]310scoped_refptr<AudioTrackInterface> PeerConnectionWrapper::CreateAudioTrack(
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]311 const std::string& label) {
312 return pc_factory()->CreateAudioTrack(label, nullptr);
313}
314
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]315scoped_refptr<VideoTrackInterface> PeerConnectionWrapper::CreateVideoTrack(
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]316 const std::string& label) {
Harald Alvestrand041ecb82023-03-20 14:13:42[diff] [blame]317 return pc_factory()->CreateVideoTrack(FakeVideoTrackSource::Create(), label);
Steve Anton9158ef62017-11-27 21:01:52[diff] [blame]318}
319
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]320scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
321 scoped_refptr<MediaStreamTrackInterface> track,
Seth Hampson845e8782018-03-02 19:34:10[diff] [blame]322 const std::vector<std::string>& stream_ids) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]323 RTCErrorOr<scoped_refptr<RtpSenderInterface>> result =
Seth Hampson845e8782018-03-02 19:34:10[diff] [blame]324 pc()->AddTrack(track, stream_ids);
Steve Anton2d6c76a2018-01-06 01:10:52[diff] [blame]325 EXPECT_EQ(RTCErrorType::NONE, result.error().type());
326 return result.MoveValue();
327}
328
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]329scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddTrack(
330 scoped_refptr<MediaStreamTrackInterface> track,
Jonas Oreland4b2a1062022-10-19 07:24:42[diff] [blame]331 const std::vector<std::string>& stream_ids,
332 const std::vector<RtpEncodingParameters>& init_send_encodings) {
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]333 RTCErrorOr<scoped_refptr<RtpSenderInterface>> result =
Jonas Oreland4b2a1062022-10-19 07:24:42[diff] [blame]334 pc()->AddTrack(track, stream_ids, init_send_encodings);
335 EXPECT_EQ(RTCErrorType::NONE, result.error().type());
336 return result.MoveValue();
337}
338
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]339scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddAudioTrack(
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]340 const std::string& track_label,
Seth Hampson845e8782018-03-02 19:34:10[diff] [blame]341 const std::vector<std::string>& stream_ids) {
342 return AddTrack(CreateAudioTrack(track_label), stream_ids);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]343}
344
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]345scoped_refptr<RtpSenderInterface> PeerConnectionWrapper::AddVideoTrack(
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]346 const std::string& track_label,
Seth Hampson845e8782018-03-02 19:34:10[diff] [blame]347 const std::vector<std::string>& stream_ids) {
348 return AddTrack(CreateVideoTrack(track_label), stream_ids);
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]349}
350
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]351scoped_refptr<DataChannelInterface> PeerConnectionWrapper::CreateDataChannel(
Jeremy Leconteeccd93e2023-02-10 08:26:50[diff] [blame]352 const std::string& label,
Florent Castelli8037fc62024-08-29 13:00:40[diff] [blame]353 const std::optional<DataChannelInit>& config) {
Jeremy Leconteeccd93e2023-02-10 08:26:50[diff] [blame]354 const DataChannelInit* config_ptr = config.has_value() ? &(*config) : nullptr;
355 auto result = pc()->CreateDataChannelOrError(label, config_ptr);
Harald Alvestranda9af50f2021-05-21 13:33:51[diff] [blame]356 if (!result.ok()) {
357 RTC_LOG(LS_ERROR) << "CreateDataChannel failed: "
358 << ToString(result.error().type()) << " "
359 << result.error().message();
360 return nullptr;
361 }
362 return result.MoveValue();
Steve Antonfa2260d2017-12-29 00:38:23[diff] [blame]363}
364
Steve Anton8d3444d2017-10-20 22:30:51[diff] [blame]365PeerConnectionInterface::SignalingState
366PeerConnectionWrapper::signaling_state() {
367 return pc()->signaling_state();
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]368}
369
Steve Antonf1c6db12017-10-13 18:13:35[diff] [blame]370bool PeerConnectionWrapper::IsIceGatheringDone() {
Steve Anton6f25b092017-10-23 16:39:20[diff] [blame]371 return observer()->ice_gathering_complete_;
372}
373
374bool PeerConnectionWrapper::IsIceConnected() {
375 return observer()->ice_connected_;
376}
377
Evan Shrubsolee6a1f702025-04-15 14:55:42[diff] [blame]378scoped_refptr<const RTCStatsReport> PeerConnectionWrapper::GetStats() {
379 auto callback = make_ref_counted<MockRTCStatsCollectorCallback>();
Niels Möllerafb246b2022-04-20 12:26:50[diff] [blame]380 pc()->GetStats(callback.get());
Evan Shrubsole3e8e4782025-01-08 11:30:31[diff] [blame]381 EXPECT_THAT(
382 WaitUntil([&] { return callback->called(); }, ::testing::IsTrue()),
383 IsRtcOk());
Steve Anton6f25b092017-10-23 16:39:20[diff] [blame]384 return callback->report();
Steve Antonf1c6db12017-10-13 18:13:35[diff] [blame]385}
386
Steve Anton94286cb2017-09-26 23:20:19[diff] [blame]387} // namespace webrtc