admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove calls to deprecated CreatePC() and CreateDC()

Browse Source 
Anything linking to //third_party/jsoncpp is hiding deprecated usage
warnings, so these were not discovered earlier.

Bug: chromium:983223
Change-Id: Id0ade4ca016f19db16377dbeeb756358a7e94fa2
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/258124
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Florent Castelli <orphis@webrtc.org>
Commit-Queue: Florent Castelli <orphis@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36463}
This commit is contained in:
Florent Castelli 2022-04-06 03:45:10 +02:00 committed by WebRTC LUCI CQ
parent 7b84f06151
commit 72424408ed
15 changed files with 205 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
pc/peer_connection_bundle_unittest.cc
View File

@ -231,14 +231,16 @@ class PeerConnectionBundleBaseTest : public ::testing::Test {
auto observer = std::make_unique<MockPeerConnectionObserver>();
RTCConfiguration modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
auto pc = pc_factory_->CreatePeerConnection(
modified_config, std::move(port_allocator), nullptr, observer.get());
if (!pc) {
PeerConnectionDependencies pc_dependencies(observer.get());
pc_dependencies.allocator = std::move(port_allocator);
auto result = pc_factory_->CreatePeerConnectionOrError(
modified_config, std::move(pc_dependencies));
if (!result.ok()) {
return nullptr;
}
auto wrapper = std::make_unique<PeerConnectionWrapperForBundleTest>(
pc_factory_, pc, std::move(observer));
pc_factory_, result.MoveValue(), std::move(observer));
wrapper->set_network(fake_network);
return wrapper;
}

16
pc/peer_connection_crypto_unittest.cc
View File

@ -101,16 +101,18 @@ class PeerConnectionCryptoBaseTest : public ::testing::Test {
auto observer = std::make_unique<MockPeerConnectionObserver>();
RTCConfiguration modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
auto pc = pc_factory_->CreatePeerConnection(
modified_config, std::move(fake_port_allocator), std::move(cert_gen),
observer.get());
if (!pc) {
PeerConnectionDependencies pc_dependencies(observer.get());
pc_dependencies.allocator = std::move(fake_port_allocator);
pc_dependencies.cert_generator = std::move(cert_gen);
auto result = pc_factory_->CreatePeerConnectionOrError(
modified_config, std::move(pc_dependencies));
if (!result.ok()) {
return nullptr;
}
observer->SetPeerConnectionInterface(pc.get());
return std::make_unique<PeerConnectionWrapper>(pc_factory_, pc,
std::move(observer));
observer->SetPeerConnectionInterface(result.value());
return std::make_unique<PeerConnectionWrapper>(
pc_factory_, result.MoveValue(), std::move(observer));
}
// Accepts the same arguments as CreatePeerConnection and adds default audio

14
pc/peer_connection_data_channel_unittest.cc
View File

@ -138,15 +138,15 @@ class PeerConnectionDataChannelBaseTest : public ::testing::Test {
auto observer = std::make_unique<MockPeerConnectionObserver>();
RTCConfiguration modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
auto pc = pc_factory->CreatePeerConnection(modified_config, nullptr,
nullptr, observer.get());
if (!pc) {
auto result = pc_factory->CreatePeerConnectionOrError(
modified_config, PeerConnectionDependencies(observer.get()));
if (!result.ok()) {
return nullptr;
}
observer->SetPeerConnectionInterface(pc.get());
observer->SetPeerConnectionInterface(result.value());
auto wrapper = std::make_unique<PeerConnectionWrapperForDataChannelTest>(
pc_factory, pc, std::move(observer));
pc_factory, result.MoveValue(), std::move(observer));
wrapper->set_sctp_transport_factory(fake_sctp_transport_factory);
return wrapper;
}
@ -159,7 +159,7 @@ class PeerConnectionDataChannelBaseTest : public ::testing::Test {
if (!wrapper) {
return nullptr;
}
EXPECT_TRUE(wrapper->pc()->CreateDataChannel("dc", nullptr));
EXPECT_TRUE(wrapper->pc()->CreateDataChannelOrError("dc", nullptr).ok());
return wrapper;
}
@ -222,7 +222,7 @@ TEST_P(PeerConnectionDataChannelTest, SctpContentAndTransportNameSetCorrectly) {
// transport.
caller->AddAudioTrack("a");
caller->AddVideoTrack("v");
caller->pc()->CreateDataChannel("dc", nullptr);
caller->pc()->CreateDataChannelOrError("dc", nullptr);
auto offer = caller->CreateOffer();
const auto& offer_contents = offer->description()->contents();

86
pc/peer_connection_factory_unittest.cc
View File

@ -189,10 +189,12 @@ TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(factory->CreatePeerConnection(
config, nullptr, std::move(cert_generator), &observer));
webrtc::PeerConnectionDependencies pc_dependencies(&observer);
pc_dependencies.cert_generator = std::move(cert_generator);
auto result =
factory->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
EXPECT_TRUE(pc.get() != nullptr);
EXPECT_TRUE(result.ok());
}
TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) {
@ -277,12 +279,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(
factory_->CreatePeerConnection(config, std::move(port_allocator_),
std::move(cert_generator), &observer_));
ASSERT_TRUE(pc.get() != NULL);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
cricket::ServerAddresses stun_servers;
rtc::SocketAddress stun1("stun.l.google.com", 19302);
stun_servers.insert(stun1);
@ -309,12 +312,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(
factory_->CreatePeerConnection(config, std::move(port_allocator_),
std::move(cert_generator), &observer_));
ASSERT_TRUE(pc.get() != NULL);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
cricket::ServerAddresses stun_servers;
rtc::SocketAddress stun1("stun.l.google.com", 19302);
stun_servers.insert(stun1);
@ -339,12 +343,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(
factory_->CreatePeerConnection(config, std::move(port_allocator_),
std::move(cert_generator), &observer_));
ASSERT_TRUE(pc.get() != NULL);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
std::vector<cricket::RelayServerConfig> turn_servers;
cricket::RelayServerConfig turn("test.com", 1234, kTurnUsername,
kTurnPassword, cricket::PROTO_UDP);
@ -362,12 +367,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(
factory_->CreatePeerConnection(config, std::move(port_allocator_),
std::move(cert_generator), &observer_));
ASSERT_TRUE(pc.get() != NULL);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
std::vector<cricket::RelayServerConfig> turn_servers;
cricket::RelayServerConfig turn("hello.com", kDefaultStunPort, kTurnUsername,
kTurnPassword, cricket::PROTO_TCP);
@ -391,12 +397,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(
factory_->CreatePeerConnection(config, std::move(port_allocator_),
std::move(cert_generator), &observer_));
ASSERT_TRUE(pc.get() != NULL);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
std::vector<cricket::RelayServerConfig> turn_servers;
cricket::RelayServerConfig turn1("hello.com", kDefaultStunTlsPort,
kTurnUsername, kTurnPassword,
@ -429,12 +436,13 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
ice_server.username = kTurnUsername;
ice_server.password = kTurnPassword;
config.servers.push_back(ice_server);
std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
new FakeRTCCertificateGenerator());
rtc::scoped_refptr<PeerConnectionInterface> pc(
factory_->CreatePeerConnection(config, std::move(port_allocator_),
std::move(cert_generator), &observer_));
ASSERT_TRUE(pc.get() != NULL);
webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator =
std::make_unique<FakeRTCCertificateGenerator>();
pc_dependencies.allocator = std::move(port_allocator_);
auto result =
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
cricket::ServerAddresses stun_servers;
rtc::SocketAddress stun1("1.2.3.4", 1234);
stun_servers.insert(stun1);

13
pc/peer_connection_header_extension_unittest.cc
View File

@ -101,11 +101,14 @@ class PeerConnectionHeaderExtensionTest
PeerConnectionInterface::RTCConfiguration config;
if (semantics)
config.sdp_semantics = *semantics;
auto pc = pc_factory->CreatePeerConnection(
config, std::move(fake_port_allocator), nullptr, observer.get());
observer->SetPeerConnectionInterface(pc.get());
return std::make_unique<PeerConnectionWrapper>(pc_factory, pc,
std::move(observer));
PeerConnectionDependencies pc_dependencies(observer.get());
pc_dependencies.allocator = std::move(fake_port_allocator);
auto result = pc_factory->CreatePeerConnectionOrError(
config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value());
return std::make_unique<PeerConnectionWrapper>(
pc_factory, result.MoveValue(), std::move(observer));
}
std::vector<RtpHeaderExtensionCapability> extensions_;

9
pc/peer_connection_histogram_unittest.cc
View File

@ -346,14 +346,15 @@ class PeerConnectionUsageHistogramTest : public ::testing::Test {
auto observer = std::make_unique<ObserverForUsageHistogramTest>();
deps.observer = observer.get();
auto pc = pc_factory->CreatePeerConnection(config, std::move(deps));
if (!pc) {
auto result =
pc_factory->CreatePeerConnectionOrError(config, std::move(deps));
if (!result.ok()) {
return nullptr;
}
observer->SetPeerConnectionInterface(pc.get());
observer->SetPeerConnectionInterface(result.value());
auto wrapper = std::make_unique<PeerConnectionWrapperForUsageHistogramTest>(
pc_factory, pc, std::move(observer));
pc_factory, result.MoveValue(), std::move(observer));
return wrapper;
}

24
pc/peer_connection_ice_unittest.cc
View File

@ -167,15 +167,17 @@ class PeerConnectionIceBaseTest : public ::testing::Test {
modified_config.sdp_semantics = sdp_semantics_;
auto observer = std::make_unique<MockPeerConnectionObserver>();
auto port_allocator_copy = port_allocator.get();
auto pc = pc_factory_->CreatePeerConnection(
modified_config, std::move(port_allocator), nullptr, observer.get());
if (!pc) {
PeerConnectionDependencies pc_dependencies(observer.get());
pc_dependencies.allocator = std::move(port_allocator);
auto result = pc_factory_->CreatePeerConnectionOrError(
modified_config, std::move(pc_dependencies));
if (!result.ok()) {
return nullptr;
}
observer->SetPeerConnectionInterface(pc.get());
observer->SetPeerConnectionInterface(result.value());
auto wrapper = std::make_unique<PeerConnectionWrapperForIceTest>(
pc_factory_, pc, std::move(observer));
pc_factory_, result.MoveValue(), std::move(observer));
wrapper->set_network(fake_network);
wrapper->port_allocator_ = port_allocator_copy;
return wrapper;
@ -1415,12 +1417,12 @@ class PeerConnectionIceConfigTest : public ::testing::Test {
std::unique_ptr<cricket::FakePortAllocator> port_allocator(
new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr));
port_allocator_ = port_allocator.get();
rtc::scoped_refptr<PeerConnectionInterface> pc(
pc_factory_->CreatePeerConnection(config, std::move(port_allocator),
nullptr /* cert_generator */,
&observer_));
EXPECT_TRUE(pc.get());
pc_ = std::move(pc);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.allocator = std::move(port_allocator);
auto result = pc_factory_->CreatePeerConnectionOrError(
config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok());
pc_ = result.MoveValue();
}
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;

133
pc/peer_connection_interface_unittest.cc
View File

@ -749,10 +749,13 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
RTCConfiguration modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
pc_ = pc_factory_->CreatePeerConnection(
modified_config, std::move(port_allocator), std::move(cert_generator),
&observer_);
ASSERT_TRUE(pc_.get() != NULL);
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.cert_generator = std::move(cert_generator);
pc_dependencies.allocator = std::move(port_allocator);
auto result = pc_factory_->CreatePeerConnectionOrError(
modified_config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
pc_ = result.MoveValue();
observer_.SetPeerConnectionInterface(pc_.get());
EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
}
@ -763,9 +766,10 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
server.uri = uri;
config.servers.push_back(server);
config.sdp_semantics = sdp_semantics_;
rtc::scoped_refptr<PeerConnectionInterface> pc =
pc_factory_->CreatePeerConnection(config, nullptr, nullptr, &observer_);
EXPECT_EQ(nullptr, pc);
PeerConnectionDependencies pc_dependencies(&observer_);
auto result = pc_factory_->CreatePeerConnectionOrError(
config, std::move(pc_dependencies));
EXPECT_FALSE(result.ok());
}
void CreatePeerConnectionExpectFail(
@ -775,9 +779,10 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
server.password = kTurnPassword;
config.servers.push_back(server);
config.sdp_semantics = sdp_semantics_;
rtc::scoped_refptr<PeerConnectionInterface> pc =
pc_factory_->CreatePeerConnection(config, nullptr, nullptr, &observer_);
EXPECT_EQ(nullptr, pc);
PeerConnectionDependencies pc_dependencies(&observer_);
auto result = pc_factory_->CreatePeerConnectionOrError(
config, std::move(pc_dependencies));
EXPECT_FALSE(result.ok());
}
void CreatePeerConnectionWithDifferentConfigurations() {
@ -1384,11 +1389,12 @@ TEST_P(PeerConnectionInterfaceTest,
webrtc::CreateBuiltinVideoEncoderFactory(),
webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
nullptr /* audio_processing */));
rtc::scoped_refptr<PeerConnectionInterface> pc(
pc_factory->CreatePeerConnection(config, std::move(port_allocator),
nullptr, &observer_));
EXPECT_TRUE(pc.get());
observer_.SetPeerConnectionInterface(pc.get());
PeerConnectionDependencies pc_dependencies(&observer_);
pc_dependencies.allocator = std::move(port_allocator);
auto result = pc_factory_->CreatePeerConnectionOrError(
config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok());
observer_.SetPeerConnectionInterface(result.value());
// Now validate that the config fields set above were applied to the
// PortAllocator, as flags or otherwise.
@ -1902,31 +1908,30 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannel) {
CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config;
rtc::scoped_refptr<DataChannelInterface> channel =
pc_->CreateDataChannel("1", &config);
EXPECT_TRUE(channel != NULL);
EXPECT_TRUE(channel->reliable());
auto channel = pc_->CreateDataChannelOrError("1", &config);
EXPECT_TRUE(channel.ok());
EXPECT_TRUE(channel.value()->reliable());
EXPECT_TRUE(observer_.renegotiation_needed_);
observer_.renegotiation_needed_ = false;
config.ordered = false;
channel = pc_->CreateDataChannel("2", &config);
EXPECT_TRUE(channel != NULL);
EXPECT_TRUE(channel->reliable());
channel = pc_->CreateDataChannelOrError("2", &config);
EXPECT_TRUE(channel.ok());
EXPECT_TRUE(channel.value()->reliable());
EXPECT_FALSE(observer_.renegotiation_needed_);
config.ordered = true;
config.maxRetransmits = 0;
channel = pc_->CreateDataChannel("3", &config);
EXPECT_TRUE(channel != NULL);
EXPECT_FALSE(channel->reliable());
channel = pc_->CreateDataChannelOrError("3", &config);
EXPECT_TRUE(channel.ok());
EXPECT_FALSE(channel.value()->reliable());
EXPECT_FALSE(observer_.renegotiation_needed_);
config.maxRetransmits = absl::nullopt;
config.maxRetransmitTime = 0;
channel = pc_->CreateDataChannel("4", &config);
EXPECT_TRUE(channel != NULL);
EXPECT_FALSE(channel->reliable());
channel = pc_->CreateDataChannelOrError("4", &config);
EXPECT_TRUE(channel.ok());
EXPECT_FALSE(channel.value()->reliable());
EXPECT_FALSE(observer_.renegotiation_needed_);
}
@ -1939,9 +1944,8 @@ TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannelWithMinusOne) {
webrtc::DataChannelInit config;
config.maxRetransmitTime = -1;
config.maxRetransmits = -1;
rtc::scoped_refptr<DataChannelInterface> channel =
pc_->CreateDataChannel("1", &config);
EXPECT_TRUE(channel != NULL);
auto channel = pc_->CreateDataChannelOrError("1", &config);
EXPECT_TRUE(channel.ok());
}
// This tests that no data channel is returned if both maxRetransmits and
@ -1956,9 +1960,8 @@ TEST_P(PeerConnectionInterfaceTest,
config.maxRetransmits = 0;
config.maxRetransmitTime = 0;
rtc::scoped_refptr<DataChannelInterface> channel =
pc_->CreateDataChannel(label, &config);
EXPECT_TRUE(channel == NULL);
auto channel = pc_->CreateDataChannelOrError(label, &config);
EXPECT_FALSE(channel.ok());
}
// The test verifies that creating a SCTP data channel with an id already in use
@ -1969,27 +1972,26 @@ TEST_P(PeerConnectionInterfaceTest,
CreatePeerConnection(rtc_config);
webrtc::DataChannelInit config;
rtc::scoped_refptr<DataChannelInterface> channel;
config.id = 1;
config.negotiated = true;
channel = pc_->CreateDataChannel("1", &config);
EXPECT_TRUE(channel != NULL);
EXPECT_EQ(1, channel->id());
auto channel = pc_->CreateDataChannelOrError("1", &config);
EXPECT_TRUE(channel.ok());
EXPECT_EQ(1, channel.value()->id());
channel = pc_->CreateDataChannel("x", &config);
EXPECT_TRUE(channel == NULL);
channel = pc_->CreateDataChannelOrError("x", &config);
EXPECT_FALSE(channel.ok());
config.id = cricket::kMaxSctpSid;
config.negotiated = true;
channel = pc_->CreateDataChannel("max", &config);
EXPECT_TRUE(channel != NULL);
EXPECT_EQ(config.id, channel->id());
channel = pc_->CreateDataChannelOrError("max", &config);
EXPECT_TRUE(channel.ok());
EXPECT_EQ(config.id, channel.value()->id());
config.id = cricket::kMaxSctpSid + 1;
config.negotiated = true;
channel = pc_->CreateDataChannel("x", &config);
EXPECT_TRUE(channel == NULL);
channel = pc_->CreateDataChannelOrError("x", &config);
EXPECT_FALSE(channel.ok());
}
// Verifies that duplicated label is allowed for SCTP data channel.
@ -1998,13 +2000,11 @@ TEST_P(PeerConnectionInterfaceTest, SctpDuplicatedLabelAllowed) {
CreatePeerConnection(rtc_config);
std::string label = "test";
rtc::scoped_refptr<DataChannelInterface> channel =
pc_->CreateDataChannel(label, nullptr);
EXPECT_NE(channel, nullptr);
auto channel = pc_->CreateDataChannelOrError(label, nullptr);
EXPECT_TRUE(channel.ok());
rtc::scoped_refptr<DataChannelInterface> dup_channel =
pc_->CreateDataChannel(label, nullptr);
EXPECT_NE(dup_channel, nullptr);
auto dup_channel = pc_->CreateDataChannelOrError(label, nullptr);
EXPECT_TRUE(dup_channel.ok());
}
#ifdef WEBRTC_HAVE_SCTP
@ -2017,8 +2017,7 @@ TEST_P(PeerConnectionInterfaceTest, DISABLED_TestRejectSctpDataChannelInAnswer)
RTCConfiguration rtc_config;
CreatePeerConnection(rtc_config);
rtc::scoped_refptr<DataChannelInterface> offer_channel(
pc_->CreateDataChannel("offer_channel", NULL));
auto offer_channel = pc_->CreateDataChannelOrError("offer_channel", NULL);
CreateOfferAsLocalDescription();
@ -2033,7 +2032,7 @@ TEST_P(PeerConnectionInterfaceTest, DISABLED_TestRejectSctpDataChannelInAnswer)
data_info->rejected = true;
DoSetRemoteDescription(std::move(answer));
EXPECT_EQ(DataChannelInterface::kClosed, offer_channel->state());
EXPECT_EQ(DataChannelInterface::kClosed, offer_channel.value()->state());
}
// Test that we can create a session description from an SDP string from
@ -2456,7 +2455,7 @@ TEST_F(PeerConnectionInterfaceTestPlanB, CloseAndTestMethods) {
pc_->RemoveStream(local_stream);
EXPECT_FALSE(pc_->AddStream(local_stream));
EXPECT_TRUE(pc_->CreateDataChannel("test", NULL) == NULL);
EXPECT_FALSE(pc_->CreateDataChannelOrError("test", NULL).ok());
EXPECT_TRUE(pc_->local_description() != NULL);
EXPECT_TRUE(pc_->remote_description() != NULL);
@ -3340,7 +3339,7 @@ TEST_P(PeerConnectionInterfaceTest,
// First, create an offer with only a data channel and apply it as a remote
// description.
pc_->CreateDataChannel("test", nullptr);
pc_->CreateDataChannelOrError("test", nullptr);
std::unique_ptr<SessionDescriptionInterface> offer;
ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
@ -3660,11 +3659,12 @@ class PeerConnectionMediaConfigTest : public ::testing::Test {
}
const cricket::MediaConfig TestCreatePeerConnection(
const RTCConfiguration& config) {
rtc::scoped_refptr<PeerConnectionInterface> pc(
pcf_->CreatePeerConnection(config, nullptr, nullptr, &observer_));
EXPECT_TRUE(pc.get());
observer_.SetPeerConnectionInterface(pc.get());
return pc->GetConfiguration().media_config;
PeerConnectionDependencies pc_dependencies(&observer_);
auto result =
pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok());
observer_.SetPeerConnectionInterface(result.value());
return result.value()->GetConfiguration().media_config;
}
rtc::scoped_refptr<PeerConnectionFactoryForTest> pcf_;
@ -3675,11 +3675,12 @@ class PeerConnectionMediaConfigTest : public ::testing::Test {
TEST_F(PeerConnectionMediaConfigTest, TestCreateAndClose) {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
rtc::scoped_refptr<PeerConnectionInterface> pc(
pcf_->CreatePeerConnection(config, nullptr, nullptr, &observer_));
EXPECT_TRUE(pc.get());
observer_.SetPeerConnectionInterface(pc.get()); // Required.
pc->Close(); // No abort -> ok.
PeerConnectionDependencies pc_dependencies(&observer_);
auto result =
pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
EXPECT_TRUE(result.ok());
observer_.SetPeerConnectionInterface(result.value());
result.value()->Close(); // No abort -> ok.
SUCCEED();
}

12
pc/peer_connection_jsep_unittest.cc
View File

@ -117,15 +117,15 @@ class PeerConnectionJsepTest : public ::testing::Test {
CreateModularPeerConnectionFactory(
CreatePeerConnectionFactoryDependencies());
auto observer = std::make_unique<MockPeerConnectionObserver>();
auto pc = pc_factory->CreatePeerConnection(config, nullptr, nullptr,
observer.get());
if (!pc) {
auto result = pc_factory->CreatePeerConnectionOrError(
config, PeerConnectionDependencies(observer.get()));
if (!result.ok()) {
return nullptr;
}
observer->SetPeerConnectionInterface(pc.get());
return std::make_unique<PeerConnectionWrapper>(pc_factory, pc,
std::move(observer));
observer->SetPeerConnectionInterface(result.value());
return std::make_unique<PeerConnectionWrapper>(
pc_factory, result.MoveValue(), std::move(observer));
}
std::unique_ptr<rtc::VirtualSocketServer> vss_;

10
pc/peer_connection_media_unittest.cc
View File

@ -141,13 +141,15 @@ class PeerConnectionMediaBaseTest : public ::testing::Test {
auto observer = std::make_unique<MockPeerConnectionObserver>();
auto modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
auto pc = pc_factory->CreatePeerConnection(modified_config,
std::move(fake_port_allocator),
nullptr, observer.get());
if (!pc) {
PeerConnectionDependencies pc_dependencies(observer.get());
pc_dependencies.allocator = std::move(fake_port_allocator);
auto result = pc_factory->CreatePeerConnectionOrError(
modified_config, std::move(pc_dependencies));
if (!result.ok()) {
return nullptr;
}
auto pc = result.MoveValue();
observer->SetPeerConnectionInterface(pc.get());
auto wrapper = std::make_unique<PeerConnectionWrapperForMediaTest>(
pc_factory, pc, std::move(observer));

12
pc/peer_connection_rtp_unittest.cc
View File

@ -135,12 +135,12 @@ class PeerConnectionRtpBaseTest : public ::testing::Test {
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnectionInternal(
const RTCConfiguration& config) {
auto observer = std::make_unique<MockPeerConnectionObserver>();
auto pc = pc_factory_->CreatePeerConnection(config, nullptr, nullptr,
observer.get());
EXPECT_TRUE(pc.get());
observer->SetPeerConnectionInterface(pc.get());
return std::make_unique<PeerConnectionWrapper>(pc_factory_, pc,
std::move(observer));
auto result = pc_factory_->CreatePeerConnectionOrError(
config, PeerConnectionDependencies(observer.get()));
EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value());
return std::make_unique<PeerConnectionWrapper>(
pc_factory_, result.MoveValue(), std::move(observer));
}
};

12
pc/peer_connection_signaling_unittest.cc
View File

@ -147,15 +147,15 @@ class PeerConnectionSignalingBaseTest : public ::testing::Test {
auto observer = std::make_unique<MockPeerConnectionObserver>();
RTCConfiguration modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
auto pc = pc_factory_->CreatePeerConnection(modified_config, nullptr,
nullptr, observer.get());
if (!pc) {
auto result = pc_factory_->CreatePeerConnectionOrError(
modified_config, PeerConnectionDependencies(observer.get()));
if (!result.ok()) {
return nullptr;
}
observer->SetPeerConnectionInterface(pc.get());
observer->SetPeerConnectionInterface(result.value());
return std::make_unique<PeerConnectionWrapperForSignalingTest>(
pc_factory_, pc, std::move(observer));
pc_factory_, result.MoveValue(), std::move(observer));
}
// Accepts the same arguments as CreatePeerConnection and adds default audio
@ -1335,7 +1335,7 @@ TEST_F(PeerConnectionSignalingUnifiedPlanTest, RtxReofferApt) {
EXPECT_TRUE(
callee->SetLocalDescription(CloneSessionDescription(answer.get())));
callee->pc()->GetTransceivers()[0]->Stop();
callee->pc()->GetTransceivers()[0]->StopStandard();
auto reoffer = callee->CreateOffer(RTCOfferAnswerOptions());
auto codecs = reoffer->description()
->contents()[0]

9
pc/peer_connection_simulcast_unittest.cc
View File

@ -137,10 +137,11 @@ class PeerConnectionSimulcastTests : public ::testing::Test {
PeerConnectionInterface::RTCConfiguration config;
config.sdp_semantics = SdpSemantics::kUnifiedPlan;
PeerConnectionDependencies pcd(observer);
auto pc = pc_factory_->CreatePeerConnection(config, std::move(pcd));
EXPECT_TRUE(pc);
observer->SetPeerConnectionInterface(pc);
return pc;
auto result =
pc_factory_->CreatePeerConnectionOrError(config, std::move(pcd));
EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value());
return result.MoveValue();
}
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnectionWrapper() {

12
pc/sdp_offer_answer_unittest.cc
View File

@ -82,12 +82,12 @@ class SdpOfferAnswerTest : public ::testing::Test {
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection(
const RTCConfiguration& config) {
auto observer = std::make_unique<MockPeerConnectionObserver>();
auto pc = pc_factory_->CreatePeerConnection(config, nullptr, nullptr,
observer.get());
EXPECT_TRUE(pc.get());
observer->SetPeerConnectionInterface(pc.get());
return std::make_unique<PeerConnectionWrapper>(pc_factory_, pc,
std::move(observer));
auto result = pc_factory_->CreatePeerConnectionOrError(
config, PeerConnectionDependencies(observer.get()));
EXPECT_TRUE(result.ok());
observer->SetPeerConnectionInterface(result.value());
return std::make_unique<PeerConnectionWrapper>(
pc_factory_, result.MoveValue(), std::move(observer));
}
protected:

11
pc/test/integration_test_helpers.h
View File

@ -410,7 +410,9 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
void CreateDataChannel(const std::string& label,
const webrtc::DataChannelInit* init) {
data_channels_.push_back(pc()->CreateDataChannel(label, init));
auto data_channel_or_error = pc()->CreateDataChannelOrError(label, init);
ASSERT_TRUE(data_channel_or_error.ok());
data_channels_.push_back(data_channel_or_error.MoveValue());
ASSERT_TRUE(data_channels_.back().get() != nullptr);
data_observers_.push_back(
std::make_unique<MockDataChannelObserver>(data_channels_.back()));
@ -825,8 +827,11 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
modified_config.set_cpu_adaptation(false);
dependencies.observer = this;
return peer_connection_factory_->CreatePeerConnection(
modified_config, std::move(dependencies));
auto peer_connection_or_error =
peer_connection_factory_->CreatePeerConnectionOrError(
modified_config, std::move(dependencies));
return peer_connection_or_error.ok() ? peer_connection_or_error.MoveValue()
: nullptr;
}
void set_signaling_message_receiver(