webrtc/p2p/base/transport_unittest.cc - Issue 2517883002: Refactoring that removes P2PTransport and DtlsTransport classes.

Side by Side Diff: webrtc/p2p/base/transport_unittest.cc

Issue 2517883002: Refactoring that removes P2PTransport and DtlsTransport classes. (Closed)

Patch Set: Rename Transport to JsepTransport. Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 * Copyright 2011 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

11 #include <memory>

12

13 #include "webrtc/base/fakesslidentity.h"

14 #include "webrtc/base/gunit.h"

15 #include "webrtc/base/network.h"

16 #include "webrtc/p2p/base/faketransportcontroller.h"

17 #include "webrtc/p2p/base/p2ptransport.h"

18

19 using cricket::Transport;

20 using cricket::FakeTransport;

21 using cricket::TransportChannel;

22 using cricket::FakeTransportChannel;

23 using cricket::IceRole;

24 using cricket::TransportDescription;

25 using rtc::SocketAddress;

26

27 static const char kIceUfrag1[] = "TESTICEUFRAG0001";

28 static const char kIcePwd1[] = "TESTICEPWD00000000000001";

29

30 static const char kIceUfrag2[] = "TESTICEUFRAG0002";

31 static const char kIcePwd2[] = "TESTICEPWD00000000000002";

32

33 class TransportTest : public testing::Test,

34 public sigslot::has_slots<> {

35 public:

36 TransportTest()

37 : transport_(new FakeTransport("test content name")), channel_(NULL) {}

38 ~TransportTest() {

39 transport_->DestroyAllChannels();

40 }

41 bool SetupChannel() {

42 channel_ = CreateChannel(1);

43 return (channel_ != NULL);

44 }

45 FakeTransportChannel* CreateChannel(int component) {

46 return static_cast<FakeTransportChannel*>(

47 transport_->CreateChannel(component));

48 }

49 void DestroyChannel() {

50 transport_->DestroyChannel(1);

51 channel_ = NULL;

52 }

53

54 protected:

55 std::unique_ptr<FakeTransport> transport_;

56 FakeTransportChannel* channel_;

57 };

58

59 // This test verifies channels are created with proper ICE

60 // role, tiebreaker and remote ice mode and credentials after offer and

61 // answer negotiations.

62 TEST_F(TransportTest, TestChannelIceParameters) {

63 transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);

64 transport_->SetIceTiebreaker(99U);

65 cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);

66 ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,

67 cricket::CA_OFFER,

68 NULL));

69 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

70 EXPECT_TRUE(SetupChannel());

71 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

72 EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());

73 EXPECT_EQ(kIceUfrag1, channel_->ice_ufrag());

74 EXPECT_EQ(kIcePwd1, channel_->ice_pwd());

75

76 cricket::TransportDescription remote_desc(kIceUfrag1, kIcePwd1);

77 ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,

78 cricket::CA_ANSWER,

79 NULL));

80 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

81 EXPECT_EQ(99U, channel_->IceTiebreaker());

82 EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());

83 // Changing the transport role from CONTROLLING to CONTROLLED.

84 transport_->SetIceRole(cricket::ICEROLE_CONTROLLED);

85 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel_->GetIceRole());

86 EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());

87 EXPECT_EQ(kIceUfrag1, channel_->remote_ice_ufrag());

88 EXPECT_EQ(kIcePwd1, channel_->remote_ice_pwd());

89 }

90

91 // Verifies that IceCredentialsChanged returns true when either ufrag or pwd

92 // changed, and false in other cases.

93 TEST_F(TransportTest, TestIceCredentialsChanged) {

94 EXPECT_TRUE(cricket::IceCredentialsChanged("u1", "p1", "u2", "p2"));

95 EXPECT_TRUE(cricket::IceCredentialsChanged("u1", "p1", "u2", "p1"));

96 EXPECT_TRUE(cricket::IceCredentialsChanged("u1", "p1", "u1", "p2"));

97 EXPECT_FALSE(cricket::IceCredentialsChanged("u1", "p1", "u1", "p1"));

98 }

99

100 // This test verifies that the callee's ICE role remains the same when the

101 // callee triggers an ICE restart.

102 //

103 // RFC5245 currently says that the role should change on an ICE restart,

104 // but this rule was intended for an ICE restart that occurs when an endpoint

105 // is changing to ICE lite (which we already handle). See discussion here:

106 // https://mailarchive.ietf.org/arch/msg/ice/C0_QRCTNcwtvUF12y28jQicPR10

107 TEST_F(TransportTest, TestIceControlledToControllingOnIceRestart) {

108 EXPECT_TRUE(SetupChannel());

109 transport_->SetIceRole(cricket::ICEROLE_CONTROLLED);

110

111 cricket::TransportDescription desc(kIceUfrag1, kIcePwd1);

112 ASSERT_TRUE(transport_->SetRemoteTransportDescription(desc,

113 cricket::CA_OFFER,

114 NULL));

115 ASSERT_TRUE(transport_->SetLocalTransportDescription(desc,

116 cricket::CA_ANSWER,

117 NULL));

118 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, transport_->ice_role());

119

120 cricket::TransportDescription new_local_desc(kIceUfrag2, kIcePwd2);

121 ASSERT_TRUE(transport_->SetLocalTransportDescription(new_local_desc,

122 cricket::CA_OFFER,

123 NULL));

124 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, transport_->ice_role());

125 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel_->GetIceRole());

126 }

127

128 // This test verifies that the caller's ICE role remains the same when the

129 // callee triggers an ICE restart.

130 //

131 // RFC5245 currently says that the role should change on an ICE restart,

132 // but this rule was intended for an ICE restart that occurs when an endpoint

133 // is changing to ICE lite (which we already handle). See discussion here:

134 // https://mailarchive.ietf.org/arch/msg/ice/C0_QRCTNcwtvUF12y28jQicPR10

135 TEST_F(TransportTest, TestIceControllingToControlledOnIceRestart) {

136 EXPECT_TRUE(SetupChannel());

137 transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);

138

139 cricket::TransportDescription desc(kIceUfrag1, kIcePwd1);

140 ASSERT_TRUE(transport_->SetLocalTransportDescription(desc,

141 cricket::CA_OFFER,

142 NULL));

143 ASSERT_TRUE(transport_->SetRemoteTransportDescription(desc,

144 cricket::CA_ANSWER,

145 NULL));

146 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

147

148 cricket::TransportDescription new_local_desc(kIceUfrag2, kIcePwd2);

149 ASSERT_TRUE(transport_->SetLocalTransportDescription(new_local_desc,

150 cricket::CA_ANSWER,

151 NULL));

152 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

153 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

154 }

155

156 // This test verifies that the caller's ICE role is still controlling after the

157 // callee triggers ICE restart if the callee's ICE mode is LITE.

158 TEST_F(TransportTest, TestIceControllingOnIceRestartIfRemoteIsIceLite) {

159 EXPECT_TRUE(SetupChannel());

160 transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);

161

162 cricket::TransportDescription desc(kIceUfrag1, kIcePwd1);

163 ASSERT_TRUE(transport_->SetLocalTransportDescription(desc,

164 cricket::CA_OFFER,

165 NULL));

166

167 cricket::TransportDescription remote_desc(

168 std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_LITE,

169 cricket::CONNECTIONROLE_NONE, NULL);

170 ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,

171 cricket::CA_ANSWER,

172 NULL));

173

174 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

175

176 cricket::TransportDescription new_local_desc(kIceUfrag2, kIcePwd2);

177 ASSERT_TRUE(transport_->SetLocalTransportDescription(new_local_desc,

178 cricket::CA_ANSWER,

179 NULL));

180 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

181 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

182 }

183

184 // Tests channel role is reversed after receiving ice-lite from remote.

185 TEST_F(TransportTest, TestSetRemoteIceLiteInOffer) {

186 transport_->SetIceRole(cricket::ICEROLE_CONTROLLED);

187 cricket::TransportDescription remote_desc(

188 std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_LITE,

189 cricket::CONNECTIONROLE_ACTPASS, NULL);

190 ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,

191 cricket::CA_OFFER,

192 NULL));

193 cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);

194 ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,

195 cricket::CA_ANSWER,

196 NULL));

197 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

198 EXPECT_TRUE(SetupChannel());

199 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

200 EXPECT_EQ(cricket::ICEMODE_LITE, channel_->remote_ice_mode());

201 }

202

203 // Tests ice-lite in remote answer.

204 TEST_F(TransportTest, TestSetRemoteIceLiteInAnswer) {

205 transport_->SetIceRole(cricket::ICEROLE_CONTROLLING);

206 cricket::TransportDescription local_desc(kIceUfrag1, kIcePwd1);

207 ASSERT_TRUE(transport_->SetLocalTransportDescription(local_desc,

208 cricket::CA_OFFER,

209 NULL));

210 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, transport_->ice_role());

211 EXPECT_TRUE(SetupChannel());

212 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

213 // Channels will be created in ICEFULL_MODE.

214 EXPECT_EQ(cricket::ICEMODE_FULL, channel_->remote_ice_mode());

215 cricket::TransportDescription remote_desc(

216 std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_LITE,

217 cricket::CONNECTIONROLE_NONE, NULL);

218 ASSERT_TRUE(transport_->SetRemoteTransportDescription(remote_desc,

219 cricket::CA_ANSWER,

220 NULL));

221 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel_->GetIceRole());

222 // After receiving remote description with ICEMODE_LITE, channel should

223 // have mode set to ICEMODE_LITE.

224 EXPECT_EQ(cricket::ICEMODE_LITE, channel_->remote_ice_mode());

225 }

226

227 TEST_F(TransportTest, TestGetStats) {

228 EXPECT_TRUE(SetupChannel());

229 cricket::TransportStats stats;

230 EXPECT_TRUE(transport_->GetStats(&stats));

231 // Note that this tests the behavior of a FakeTransportChannel.

232 ASSERT_EQ(1U, stats.channel_stats.size());

233 EXPECT_EQ(1, stats.channel_stats[0].component);

234 // Set local transport description for FakeTransport before connecting.

235 TransportDescription faketransport_desc(

236 std::vector<std::string>(),

237 rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH),

238 rtc::CreateRandomString(cricket::ICE_PWD_LENGTH), cricket::ICEMODE_FULL,

239 cricket::CONNECTIONROLE_NONE, nullptr);

240 transport_->SetLocalTransportDescription(faketransport_desc,

241 cricket::CA_OFFER, nullptr);

242 EXPECT_TRUE(transport_->GetStats(&stats));

243 ASSERT_EQ(1U, stats.channel_stats.size());

244 EXPECT_EQ(1, stats.channel_stats[0].component);

245 }

246

247 // Tests that VerifyCertificateFingerprint only returns true when the

248 // certificate matches the fingerprint.

249 TEST_F(TransportTest, TestVerifyCertificateFingerprint) {

250 std::string error_desc;

251 EXPECT_FALSE(

252 transport_->VerifyCertificateFingerprint(nullptr, nullptr, &error_desc));

253 rtc::KeyType key_types[] = {rtc::KT_RSA, rtc::KT_ECDSA};

254

255 for (auto& key_type : key_types) {

256 rtc::scoped_refptr<rtc::RTCCertificate> certificate =

257 rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(

258 rtc::SSLIdentity::Generate("testing", key_type)));

259 ASSERT_NE(nullptr, certificate);

260

261 std::string digest_algorithm;

262 ASSERT_TRUE(certificate->ssl_certificate().GetSignatureDigestAlgorithm(

263 &digest_algorithm));

264 ASSERT_FALSE(digest_algorithm.empty());

265 std::unique_ptr<rtc::SSLFingerprint> good_fingerprint(

266 rtc::SSLFingerprint::Create(digest_algorithm, certificate->identity()));

267 ASSERT_NE(nullptr, good_fingerprint);

268

269 EXPECT_TRUE(transport_->VerifyCertificateFingerprint(

270 certificate.get(), good_fingerprint.get(), &error_desc));

271 EXPECT_FALSE(transport_->VerifyCertificateFingerprint(

272 certificate.get(), nullptr, &error_desc));

273 EXPECT_FALSE(transport_->VerifyCertificateFingerprint(

274 nullptr, good_fingerprint.get(), &error_desc));

275

276 rtc::SSLFingerprint bad_fingerprint = *good_fingerprint;

277 bad_fingerprint.digest.AppendData("0", 1);

278 EXPECT_FALSE(transport_->VerifyCertificateFingerprint(

279 certificate.get(), &bad_fingerprint, &error_desc));

280 }

281 }

282

283 // Tests that NegotiateRole sets the SSL role correctly.

284 TEST_F(TransportTest, TestNegotiateRole) {

285 TransportDescription local_desc(kIceUfrag1, kIcePwd1);

286 TransportDescription remote_desc(kIceUfrag2, kIcePwd2);

287

288 struct NegotiateRoleParams {

289 cricket::ConnectionRole local_role;

290 cricket::ConnectionRole remote_role;

291 cricket::ContentAction local_action;

292 cricket::ContentAction remote_action;

293 };

294

295 rtc::SSLRole ssl_role;

296 std::string error_desc;

297

298 // Parameters which set the SSL role to SSL_CLIENT.

299 NegotiateRoleParams valid_client_params[] = {

300 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_ACTPASS,

301 cricket::CA_ANSWER, cricket::CA_OFFER},

302 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_ACTPASS,

303 cricket::CA_PRANSWER, cricket::CA_OFFER},

304 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_PASSIVE,

305 cricket::CA_OFFER, cricket::CA_ANSWER},

306 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_PASSIVE,

307 cricket::CA_OFFER, cricket::CA_PRANSWER}};

308

309 for (auto& param : valid_client_params) {

310 local_desc.connection_role = param.local_role;

311 remote_desc.connection_role = param.remote_role;

312

313 ASSERT_TRUE(transport_->SetRemoteTransportDescription(

314 remote_desc, param.remote_action, nullptr));

315 ASSERT_TRUE(transport_->SetLocalTransportDescription(

316 local_desc, param.local_action, nullptr));

317 EXPECT_TRUE(

318 transport_->NegotiateRole(param.local_action, &ssl_role, &error_desc));

319 EXPECT_EQ(rtc::SSL_CLIENT, ssl_role);

320 }

321

322 // Parameters which set the SSL role to SSL_SERVER.

323 NegotiateRoleParams valid_server_params[] = {

324 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTPASS,

325 cricket::CA_ANSWER, cricket::CA_OFFER},

326 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTPASS,

327 cricket::CA_PRANSWER, cricket::CA_OFFER},

328 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE,

329 cricket::CA_OFFER, cricket::CA_ANSWER},

330 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTIVE,

331 cricket::CA_OFFER, cricket::CA_PRANSWER}};

332

333 for (auto& param : valid_server_params) {

334 local_desc.connection_role = param.local_role;

335 remote_desc.connection_role = param.remote_role;

336

337 ASSERT_TRUE(transport_->SetRemoteTransportDescription(

338 remote_desc, param.remote_action, nullptr));

339 ASSERT_TRUE(transport_->SetLocalTransportDescription(

340 local_desc, param.local_action, nullptr));

341 EXPECT_TRUE(

342 transport_->NegotiateRole(param.local_action, &ssl_role, &error_desc));

343 EXPECT_EQ(rtc::SSL_SERVER, ssl_role);

344 }

345

346 // Invalid parameters due to both peers having a duplicate role.

347 NegotiateRoleParams duplicate_params[] = {

348 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_ACTIVE,

349 cricket::CA_ANSWER, cricket::CA_OFFER},

350 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTPASS,

351 cricket::CA_ANSWER, cricket::CA_OFFER},

352 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_PASSIVE,

353 cricket::CA_ANSWER, cricket::CA_OFFER},

354 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_ACTIVE,

355 cricket::CA_PRANSWER, cricket::CA_OFFER},

356 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTPASS,

357 cricket::CA_PRANSWER, cricket::CA_OFFER},

358 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_PASSIVE,

359 cricket::CA_PRANSWER, cricket::CA_OFFER},

360 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_ACTIVE,

361 cricket::CA_OFFER, cricket::CA_ANSWER},

362 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTPASS,

363 cricket::CA_OFFER, cricket::CA_ANSWER},

364 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_PASSIVE,

365 cricket::CA_OFFER, cricket::CA_ANSWER},

366 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_ACTIVE,

367 cricket::CA_OFFER, cricket::CA_PRANSWER},

368 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_ACTPASS,

369 cricket::CA_OFFER, cricket::CA_PRANSWER},

370 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_PASSIVE,

371 cricket::CA_OFFER, cricket::CA_PRANSWER}};

372

373 for (auto& param : duplicate_params) {

374 local_desc.connection_role = param.local_role;

375 remote_desc.connection_role = param.remote_role;

376

377 ASSERT_TRUE(transport_->SetRemoteTransportDescription(

378 remote_desc, param.remote_action, nullptr));

379 ASSERT_TRUE(transport_->SetLocalTransportDescription(

380 local_desc, param.local_action, nullptr));

381 EXPECT_FALSE(

382 transport_->NegotiateRole(param.local_action, &ssl_role, &error_desc));

383 }

384

385 // Invalid parameters due to the offerer not using ACTPASS.

386 NegotiateRoleParams offerer_without_actpass_params[] = {

387 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_PASSIVE,

388 cricket::CA_ANSWER, cricket::CA_OFFER},

389 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTIVE,

390 cricket::CA_ANSWER, cricket::CA_OFFER},

391 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_PASSIVE,

392 cricket::CA_ANSWER, cricket::CA_OFFER},

393 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_PASSIVE,

394 cricket::CA_PRANSWER, cricket::CA_OFFER},

395 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTIVE,

396 cricket::CA_PRANSWER, cricket::CA_OFFER},

397 {cricket::CONNECTIONROLE_ACTPASS, cricket::CONNECTIONROLE_PASSIVE,

398 cricket::CA_PRANSWER, cricket::CA_OFFER},

399 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_PASSIVE,

400 cricket::CA_OFFER, cricket::CA_ANSWER},

401 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTIVE,

402 cricket::CA_OFFER, cricket::CA_ANSWER},

403 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTPASS,

404 cricket::CA_OFFER, cricket::CA_ANSWER},

405 {cricket::CONNECTIONROLE_ACTIVE, cricket::CONNECTIONROLE_PASSIVE,

406 cricket::CA_OFFER, cricket::CA_PRANSWER},

407 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTIVE,

408 cricket::CA_OFFER, cricket::CA_PRANSWER},

409 {cricket::CONNECTIONROLE_PASSIVE, cricket::CONNECTIONROLE_ACTPASS,

410 cricket::CA_OFFER, cricket::CA_PRANSWER}};

411

412 for (auto& param : offerer_without_actpass_params) {

413 local_desc.connection_role = param.local_role;

414 remote_desc.connection_role = param.remote_role;

415

416 ASSERT_TRUE(transport_->SetRemoteTransportDescription(

417 remote_desc, param.remote_action, nullptr));

418 ASSERT_TRUE(transport_->SetLocalTransportDescription(

419 local_desc, param.local_action, nullptr));

420 EXPECT_FALSE(

421 transport_->NegotiateRole(param.local_action, &ssl_role, &error_desc));

422 }

423 }

OLD	NEW

« webrtc/p2p/base/jseptransport.h ('K') | « webrtc/p2p/base/transport.cc ('k') | webrtc/p2p/base/transportchannel.h » ('j') | webrtc/p2p/base/transportcontroller.h » ('J')