Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(763)

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

Issue 1353713002: Remove GICE (again). (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: Undo .gclient Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « webrtc/p2p/base/p2ptransportchannel.cc ('k') | webrtc/p2p/base/port.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2009 The WebRTC Project Authors. All rights reserved. 2 * Copyright 2009 The WebRTC Project Authors. All rights reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 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 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 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 14 matching lines...) Expand all
25 #include "webrtc/base/physicalsocketserver.h" 25 #include "webrtc/base/physicalsocketserver.h"
26 #include "webrtc/base/proxyserver.h" 26 #include "webrtc/base/proxyserver.h"
27 #include "webrtc/base/socketaddress.h" 27 #include "webrtc/base/socketaddress.h"
28 #include "webrtc/base/ssladapter.h" 28 #include "webrtc/base/ssladapter.h"
29 #include "webrtc/base/thread.h" 29 #include "webrtc/base/thread.h"
30 #include "webrtc/base/virtualsocketserver.h" 30 #include "webrtc/base/virtualsocketserver.h"
31 31
32 using cricket::kDefaultPortAllocatorFlags; 32 using cricket::kDefaultPortAllocatorFlags;
33 using cricket::kMinimumStepDelay; 33 using cricket::kMinimumStepDelay;
34 using cricket::kDefaultStepDelay; 34 using cricket::kDefaultStepDelay;
35 using cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG;
36 using cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET; 35 using cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET;
37 using cricket::ServerAddresses; 36 using cricket::ServerAddresses;
38 using rtc::SocketAddress; 37 using rtc::SocketAddress;
39 38
40 static const int kDefaultTimeout = 1000; 39 static const int kDefaultTimeout = 1000;
41 static const int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN | 40 static const int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
42 cricket::PORTALLOCATOR_DISABLE_RELAY | 41 cricket::PORTALLOCATOR_DISABLE_RELAY |
43 cricket::PORTALLOCATOR_DISABLE_TCP; 42 cricket::PORTALLOCATOR_DISABLE_TCP;
44 // Addresses on the public internet. 43 // Addresses on the public internet.
45 static const SocketAddress kPublicAddrs[2] = 44 static const SocketAddress kPublicAddrs[2] =
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after
170 169
171 struct Result { 170 struct Result {
172 Result(const std::string& lt, const std::string& lp, 171 Result(const std::string& lt, const std::string& lp,
173 const std::string& rt, const std::string& rp, 172 const std::string& rt, const std::string& rp,
174 const std::string& lt2, const std::string& lp2, 173 const std::string& lt2, const std::string& lp2,
175 const std::string& rt2, const std::string& rp2, int wait) 174 const std::string& rt2, const std::string& rp2, int wait)
176 : local_type(lt), local_proto(lp), remote_type(rt), remote_proto(rp), 175 : local_type(lt), local_proto(lp), remote_type(rt), remote_proto(rp),
177 local_type2(lt2), local_proto2(lp2), remote_type2(rt2), 176 local_type2(lt2), local_proto2(lp2), remote_type2(rt2),
178 remote_proto2(rp2), connect_wait(wait) { 177 remote_proto2(rp2), connect_wait(wait) {
179 } 178 }
179
180 std::string local_type; 180 std::string local_type;
181 std::string local_proto; 181 std::string local_proto;
182 std::string remote_type; 182 std::string remote_type;
183 std::string remote_proto; 183 std::string remote_proto;
184 std::string local_type2; 184 std::string local_type2;
185 std::string local_proto2; 185 std::string local_proto2;
186 std::string remote_type2; 186 std::string remote_type2;
187 std::string remote_proto2; 187 std::string remote_proto2;
188 int connect_wait; 188 int connect_wait;
189 }; 189 };
(...skipping 20 matching lines...) Expand all
210 } 210 }
211 cricket::TransportChannel* channel; 211 cricket::TransportChannel* channel;
212 cricket::Candidate candidate; 212 cricket::Candidate candidate;
213 }; 213 };
214 214
215 struct Endpoint { 215 struct Endpoint {
216 Endpoint() 216 Endpoint()
217 : role_(cricket::ICEROLE_UNKNOWN), 217 : role_(cricket::ICEROLE_UNKNOWN),
218 tiebreaker_(0), 218 tiebreaker_(0),
219 role_conflict_(false), 219 role_conflict_(false),
220 save_candidates_(false), 220 save_candidates_(false) {}
221 protocol_type_(cricket::ICEPROTO_GOOGLE) {}
222 bool HasChannel(cricket::TransportChannel* ch) { 221 bool HasChannel(cricket::TransportChannel* ch) {
223 return (ch == cd1_.ch_.get() || ch == cd2_.ch_.get()); 222 return (ch == cd1_.ch_.get() || ch == cd2_.ch_.get());
224 } 223 }
225 ChannelData* GetChannelData(cricket::TransportChannel* ch) { 224 ChannelData* GetChannelData(cricket::TransportChannel* ch) {
226 if (!HasChannel(ch)) return NULL; 225 if (!HasChannel(ch)) return NULL;
227 if (cd1_.ch_.get() == ch) 226 if (cd1_.ch_.get() == ch)
228 return &cd1_; 227 return &cd1_;
229 else 228 else
230 return &cd2_; 229 return &cd2_;
231 } 230 }
232 231
233 void SetIceRole(cricket::IceRole role) { role_ = role; } 232 void SetIceRole(cricket::IceRole role) { role_ = role; }
234 cricket::IceRole ice_role() { return role_; } 233 cricket::IceRole ice_role() { return role_; }
235 void SetIceProtocolType(cricket::IceProtocolType type) {
236 protocol_type_ = type;
237 }
238 cricket::IceProtocolType protocol_type() { return protocol_type_; }
239 void SetIceTiebreaker(uint64 tiebreaker) { tiebreaker_ = tiebreaker; } 234 void SetIceTiebreaker(uint64 tiebreaker) { tiebreaker_ = tiebreaker; }
240 uint64 GetIceTiebreaker() { return tiebreaker_; } 235 uint64 GetIceTiebreaker() { return tiebreaker_; }
241 void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; } 236 void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; }
242 bool role_conflict() { return role_conflict_; } 237 bool role_conflict() { return role_conflict_; }
243 void SetAllocationStepDelay(uint32 delay) { 238 void SetAllocationStepDelay(uint32 delay) {
244 allocator_->set_step_delay(delay); 239 allocator_->set_step_delay(delay);
245 } 240 }
246 void SetAllowTcpListen(bool allow_tcp_listen) { 241 void SetAllowTcpListen(bool allow_tcp_listen) {
247 allocator_->set_allow_tcp_listen(allow_tcp_listen); 242 allocator_->set_allow_tcp_listen(allow_tcp_listen);
248 } 243 }
249 244
250 rtc::FakeNetworkManager network_manager_; 245 rtc::FakeNetworkManager network_manager_;
251 rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_; 246 rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
252 ChannelData cd1_; 247 ChannelData cd1_;
253 ChannelData cd2_; 248 ChannelData cd2_;
254 cricket::IceRole role_; 249 cricket::IceRole role_;
255 uint64 tiebreaker_; 250 uint64 tiebreaker_;
256 bool role_conflict_; 251 bool role_conflict_;
257 bool save_candidates_; 252 bool save_candidates_;
258 cricket::IceProtocolType protocol_type_;
259 std::vector<CandidateData*> saved_candidates_; 253 std::vector<CandidateData*> saved_candidates_;
260 }; 254 };
261 255
262 ChannelData* GetChannelData(cricket::TransportChannel* channel) { 256 ChannelData* GetChannelData(cricket::TransportChannel* channel) {
263 if (ep1_.HasChannel(channel)) 257 if (ep1_.HasChannel(channel))
264 return ep1_.GetChannelData(channel); 258 return ep1_.GetChannelData(channel);
265 else 259 else
266 return ep2_.GetChannelData(channel); 260 return ep2_.GetChannelData(channel);
267 } 261 }
268 262
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
304 cricket::P2PTransportChannel* channel = new cricket::P2PTransportChannel( 298 cricket::P2PTransportChannel* channel = new cricket::P2PTransportChannel(
305 "test content name", component, NULL, GetAllocator(endpoint)); 299 "test content name", component, NULL, GetAllocator(endpoint));
306 channel->SignalRequestSignaling.connect( 300 channel->SignalRequestSignaling.connect(
307 this, &P2PTransportChannelTestBase::OnChannelRequestSignaling); 301 this, &P2PTransportChannelTestBase::OnChannelRequestSignaling);
308 channel->SignalCandidateReady.connect(this, 302 channel->SignalCandidateReady.connect(this,
309 &P2PTransportChannelTestBase::OnCandidate); 303 &P2PTransportChannelTestBase::OnCandidate);
310 channel->SignalReadPacket.connect( 304 channel->SignalReadPacket.connect(
311 this, &P2PTransportChannelTestBase::OnReadPacket); 305 this, &P2PTransportChannelTestBase::OnReadPacket);
312 channel->SignalRoleConflict.connect( 306 channel->SignalRoleConflict.connect(
313 this, &P2PTransportChannelTestBase::OnRoleConflict); 307 this, &P2PTransportChannelTestBase::OnRoleConflict);
314 channel->SetIceProtocolType(GetEndpoint(endpoint)->protocol_type());
315 channel->SetIceCredentials(local_ice_ufrag, local_ice_pwd); 308 channel->SetIceCredentials(local_ice_ufrag, local_ice_pwd);
316 if (clear_remote_candidates_ufrag_pwd_) { 309 if (clear_remote_candidates_ufrag_pwd_) {
317 // This only needs to be set if we're clearing them from the 310 // This only needs to be set if we're clearing them from the
318 // candidates. Some unit tests rely on this not being set. 311 // candidates. Some unit tests rely on this not being set.
319 channel->SetRemoteIceCredentials(remote_ice_ufrag, remote_ice_pwd); 312 channel->SetRemoteIceCredentials(remote_ice_ufrag, remote_ice_pwd);
320 } 313 }
321 channel->SetIceRole(GetEndpoint(endpoint)->ice_role()); 314 channel->SetIceRole(GetEndpoint(endpoint)->ice_role());
322 channel->SetIceTiebreaker(GetEndpoint(endpoint)->GetIceTiebreaker()); 315 channel->SetIceTiebreaker(GetEndpoint(endpoint)->GetIceTiebreaker());
323 channel->Connect(); 316 channel->Connect();
324 return channel; 317 return channel;
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
372 void SetProxy(int endpoint, rtc::ProxyType type) { 365 void SetProxy(int endpoint, rtc::ProxyType type) {
373 rtc::ProxyInfo info; 366 rtc::ProxyInfo info;
374 info.type = type; 367 info.type = type;
375 info.address = (type == rtc::PROXY_HTTPS) ? 368 info.address = (type == rtc::PROXY_HTTPS) ?
376 kHttpsProxyAddrs[endpoint] : kSocksProxyAddrs[endpoint]; 369 kHttpsProxyAddrs[endpoint] : kSocksProxyAddrs[endpoint];
377 GetAllocator(endpoint)->set_proxy("unittest/1.0", info); 370 GetAllocator(endpoint)->set_proxy("unittest/1.0", info);
378 } 371 }
379 void SetAllocatorFlags(int endpoint, int flags) { 372 void SetAllocatorFlags(int endpoint, int flags) {
380 GetAllocator(endpoint)->set_flags(flags); 373 GetAllocator(endpoint)->set_flags(flags);
381 } 374 }
382 void SetIceProtocol(int endpoint, cricket::IceProtocolType type) {
383 GetEndpoint(endpoint)->SetIceProtocolType(type);
384 }
385 void SetIceRole(int endpoint, cricket::IceRole role) { 375 void SetIceRole(int endpoint, cricket::IceRole role) {
386 GetEndpoint(endpoint)->SetIceRole(role); 376 GetEndpoint(endpoint)->SetIceRole(role);
387 } 377 }
388 void SetIceTiebreaker(int endpoint, uint64 tiebreaker) { 378 void SetIceTiebreaker(int endpoint, uint64 tiebreaker) {
389 GetEndpoint(endpoint)->SetIceTiebreaker(tiebreaker); 379 GetEndpoint(endpoint)->SetIceTiebreaker(tiebreaker);
390 } 380 }
391 bool GetRoleConflict(int endpoint) { 381 bool GetRoleConflict(int endpoint) {
392 return GetEndpoint(endpoint)->role_conflict(); 382 return GetEndpoint(endpoint)->role_conflict();
393 } 383 }
394 void SetAllocationStepDelay(int endpoint, uint32 delay) { 384 void SetAllocationStepDelay(int endpoint, uint32 delay) {
395 return GetEndpoint(endpoint)->SetAllocationStepDelay(delay); 385 return GetEndpoint(endpoint)->SetAllocationStepDelay(delay);
396 } 386 }
397 void SetAllowTcpListen(int endpoint, bool allow_tcp_listen) { 387 void SetAllowTcpListen(int endpoint, bool allow_tcp_listen) {
398 return GetEndpoint(endpoint)->SetAllowTcpListen(allow_tcp_listen); 388 return GetEndpoint(endpoint)->SetAllowTcpListen(allow_tcp_listen);
399 } 389 }
400 390
391 bool IsLocalToPrflxOrTheReverse(const Result& expected) {
392 return ((expected.local_type == "local" &&
393 expected.remote_type == "prflx") ||
394 (expected.local_type == "prflx" &&
395 expected.remote_type == "local"));
396 }
397
398 // Return true if the approprite parts of the expected Result, based
399 // on the local and remote candidate of ep1_ch1, match. This can be
400 // used in an EXPECT_TRUE_WAIT.
401 bool CheckCandidate1(const Result& expected) {
402 const std::string& local_type = LocalCandidate(ep1_ch1())->type();
403 const std::string& local_proto = LocalCandidate(ep1_ch1())->protocol();
404 const std::string& remote_type = RemoteCandidate(ep1_ch1())->type();
405 const std::string& remote_proto = RemoteCandidate(ep1_ch1())->protocol();
406 return ((local_proto == expected.local_proto &&
407 remote_proto == expected.remote_proto) &&
408 ((local_type == expected.local_type &&
409 remote_type == expected.remote_type) ||
410 // Sometimes we expect local -> prflx or prflx -> local
411 // and instead get prflx -> local or local -> prflx, and
412 // that's OK.
413 (IsLocalToPrflxOrTheReverse(expected) &&
414 local_type == expected.remote_type &&
415 remote_type == expected.local_type)));
416 }
417
418 // EXPECT_EQ on the approprite parts of the expected Result, based
419 // on the local and remote candidate of ep1_ch1. This is like
420 // CheckCandidate1, except that it will provide more detail about
421 // what didn't match.
422 void ExpectCandidate1(const Result& expected) {
423 if (CheckCandidate1(expected)) {
424 return;
425 }
426
427 const std::string& local_type = LocalCandidate(ep1_ch1())->type();
428 const std::string& local_proto = LocalCandidate(ep1_ch1())->protocol();
429 const std::string& remote_type = RemoteCandidate(ep1_ch1())->type();
430 const std::string& remote_proto = RemoteCandidate(ep1_ch1())->protocol();
431 EXPECT_EQ(expected.local_type, local_type);
432 EXPECT_EQ(expected.remote_type, remote_type);
433 EXPECT_EQ(expected.local_proto, local_proto);
434 EXPECT_EQ(expected.remote_proto, remote_proto);
435 }
436
437 // Return true if the approprite parts of the expected Result, based
438 // on the local and remote candidate of ep2_ch1, match. This can be
439 // used in an EXPECT_TRUE_WAIT.
440 bool CheckCandidate2(const Result& expected) {
441 const std::string& local_type = LocalCandidate(ep2_ch1())->type();
442 // const std::string& remote_type = RemoteCandidate(ep2_ch1())->type();
443 const std::string& local_proto = LocalCandidate(ep2_ch1())->protocol();
444 const std::string& remote_proto = RemoteCandidate(ep2_ch1())->protocol();
445 // Removed remote_type comparision aginst best connection remote
446 // candidate. This is done to handle remote type discrepancy from
447 // local to stun based on the test type.
448 // For example in case of Open -> NAT, ep2 channels will have LULU
449 // and in other cases like NAT -> NAT it will be LUSU. To avoid these
450 // mismatches and we are doing comparision in different way.
451 // i.e. when don't match its remote type is either local or stun.
452 // TODO(ronghuawu): Refine the test criteria.
453 // https://code.google.com/p/webrtc/issues/detail?id=1953
454 return ((local_proto == expected.local_proto2 &&
455 remote_proto == expected.remote_proto2) &&
456 (local_type == expected.local_type2 ||
457 // Sometimes we expect local -> prflx or prflx -> local
458 // and instead get prflx -> local or local -> prflx, and
459 // that's OK.
460 (IsLocalToPrflxOrTheReverse(expected) &&
461 local_type == expected.remote_type2)));
462 }
463
464 // EXPECT_EQ on the approprite parts of the expected Result, based
465 // on the local and remote candidate of ep2_ch1. This is like
466 // CheckCandidate2, except that it will provide more detail about
467 // what didn't match.
468 void ExpectCandidate2(const Result& expected) {
469 if (CheckCandidate2(expected)) {
470 return;
471 }
472
473 const std::string& local_type = LocalCandidate(ep2_ch1())->type();
474 const std::string& local_proto = LocalCandidate(ep2_ch1())->protocol();
475 const std::string& remote_type = RemoteCandidate(ep2_ch1())->type();
476 EXPECT_EQ(expected.local_proto2, local_proto);
477 EXPECT_EQ(expected.remote_proto2, remote_type);
478 EXPECT_EQ(expected.local_type2, local_type);
479 if (remote_type != expected.remote_type2) {
480 EXPECT_TRUE(expected.remote_type2 == cricket::LOCAL_PORT_TYPE ||
481 expected.remote_type2 == cricket::STUN_PORT_TYPE);
482 EXPECT_TRUE(remote_type == cricket::LOCAL_PORT_TYPE ||
483 remote_type == cricket::STUN_PORT_TYPE ||
484 remote_type == cricket::PRFLX_PORT_TYPE);
485 }
486 }
487
401 void Test(const Result& expected) { 488 void Test(const Result& expected) {
402 int32 connect_start = rtc::Time(), connect_time; 489 int32 connect_start = rtc::Time(), connect_time;
403 490
404 // Create the channels and wait for them to connect. 491 // Create the channels and wait for them to connect.
405 CreateChannels(1); 492 CreateChannels(1);
406 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL && 493 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL &&
407 ep2_ch1() != NULL && 494 ep2_ch1() != NULL &&
408 ep1_ch1()->readable() && 495 ep1_ch1()->readable() &&
409 ep1_ch1()->writable() && 496 ep1_ch1()->writable() &&
410 ep2_ch1()->readable() && 497 ep2_ch1()->readable() &&
411 ep2_ch1()->writable(), 498 ep2_ch1()->writable(),
412 expected.connect_wait, 499 expected.connect_wait,
413 1000); 500 1000);
414 connect_time = rtc::TimeSince(connect_start); 501 connect_time = rtc::TimeSince(connect_start);
415 if (connect_time < expected.connect_wait) { 502 if (connect_time < expected.connect_wait) {
416 LOG(LS_INFO) << "Connect time: " << connect_time << " ms"; 503 LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
417 } else { 504 } else {
418 LOG(LS_INFO) << "Connect time: " << "TIMEOUT (" 505 LOG(LS_INFO) << "Connect time: " << "TIMEOUT ("
419 << expected.connect_wait << " ms)"; 506 << expected.connect_wait << " ms)";
420 } 507 }
421 508
422 // Allow a few turns of the crank for the best connections to emerge. 509 // Allow a few turns of the crank for the best connections to emerge.
423 // This may take up to 2 seconds. 510 // This may take up to 2 seconds.
424 if (ep1_ch1()->best_connection() && 511 if (ep1_ch1()->best_connection() &&
425 ep2_ch1()->best_connection()) { 512 ep2_ch1()->best_connection()) {
426 int32 converge_start = rtc::Time(), converge_time; 513 int32 converge_start = rtc::Time(), converge_time;
427 int converge_wait = 2000; 514 int converge_wait = 2000;
428 EXPECT_TRUE_WAIT_MARGIN( 515 EXPECT_TRUE_WAIT_MARGIN(CheckCandidate1(expected),
429 LocalCandidate(ep1_ch1())->type() == expected.local_type && 516 converge_wait, converge_wait);
430 LocalCandidate(ep1_ch1())->protocol() == expected.local_proto &&
431 RemoteCandidate(ep1_ch1())->type() == expected.remote_type &&
432 RemoteCandidate(ep1_ch1())->protocol() == expected.remote_proto,
433 converge_wait,
434 converge_wait);
435
436 // Also do EXPECT_EQ on each part so that failures are more verbose. 517 // Also do EXPECT_EQ on each part so that failures are more verbose.
437 EXPECT_EQ(expected.local_type, LocalCandidate(ep1_ch1())->type()); 518 ExpectCandidate1(expected);
438 EXPECT_EQ(expected.local_proto, LocalCandidate(ep1_ch1())->protocol());
439 EXPECT_EQ(expected.remote_type, RemoteCandidate(ep1_ch1())->type());
440 EXPECT_EQ(expected.remote_proto, RemoteCandidate(ep1_ch1())->protocol());
441 519
442 // Verifying remote channel best connection information. This is done 520 // Verifying remote channel best connection information. This is done
443 // only for the RFC 5245 as controlled agent will use USE-CANDIDATE 521 // only for the RFC 5245 as controlled agent will use USE-CANDIDATE
444 // from controlling (ep1) agent. We can easily predict from EP1 result 522 // from controlling (ep1) agent. We can easily predict from EP1 result
445 // matrix. 523 // matrix.
446 if (ep2_.protocol_type_ == cricket::ICEPROTO_RFC5245) {
447 // Checking for best connection candidates information at remote.
448 EXPECT_TRUE_WAIT(
449 LocalCandidate(ep2_ch1())->type() == expected.local_type2 &&
450 LocalCandidate(ep2_ch1())->protocol() == expected.local_proto2 &&
451 RemoteCandidate(ep2_ch1())->protocol() == expected.remote_proto2,
452 kDefaultTimeout);
453 524
454 // For verbose 525 // Checking for best connection candidates information at remote.
455 EXPECT_EQ(expected.local_type2, LocalCandidate(ep2_ch1())->type()); 526 EXPECT_TRUE_WAIT(CheckCandidate2(expected), kDefaultTimeout);
456 EXPECT_EQ(expected.local_proto2, LocalCandidate(ep2_ch1())->protocol()); 527 // For verbose
457 EXPECT_EQ(expected.remote_proto2, 528 ExpectCandidate2(expected);
458 RemoteCandidate(ep2_ch1())->protocol());
459 // Removed remote_type comparision aginst best connection remote
460 // candidate. This is done to handle remote type discrepancy from
461 // local to stun based on the test type.
462 // For example in case of Open -> NAT, ep2 channels will have LULU
463 // and in other cases like NAT -> NAT it will be LUSU. To avoid these
464 // mismatches and we are doing comparision in different way.
465 // i.e. when don't match its remote type is either local or stun.
466 // TODO(ronghuawu): Refine the test criteria.
467 // https://code.google.com/p/webrtc/issues/detail?id=1953
468 if (expected.remote_type2 != RemoteCandidate(ep2_ch1())->type()) {
469 EXPECT_TRUE(expected.remote_type2 == cricket::LOCAL_PORT_TYPE ||
470 expected.remote_type2 == cricket::STUN_PORT_TYPE);
471 EXPECT_TRUE(
472 RemoteCandidate(ep2_ch1())->type() == cricket::LOCAL_PORT_TYPE ||
473 RemoteCandidate(ep2_ch1())->type() == cricket::STUN_PORT_TYPE ||
474 RemoteCandidate(ep2_ch1())->type() == cricket::PRFLX_PORT_TYPE);
475 }
476 }
477 529
478 converge_time = rtc::TimeSince(converge_start); 530 converge_time = rtc::TimeSince(converge_start);
479 if (converge_time < converge_wait) { 531 if (converge_time < converge_wait) {
480 LOG(LS_INFO) << "Converge time: " << converge_time << " ms"; 532 LOG(LS_INFO) << "Converge time: " << converge_time << " ms";
481 } else { 533 } else {
482 LOG(LS_INFO) << "Converge time: " << "TIMEOUT (" 534 LOG(LS_INFO) << "Converge time: " << "TIMEOUT ("
483 << converge_wait << " ms)"; 535 << converge_wait << " ms)";
484 } 536 }
485 } 537 }
486 // Try sending some data to other end. 538 // Try sending some data to other end.
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
543 old_remote_candidate1->generation(), 595 old_remote_candidate1->generation(),
544 1000, 1000); 596 1000, 1000);
545 EXPECT_TRUE_WAIT_MARGIN(RemoteCandidate(ep2_ch1())->generation() != 597 EXPECT_TRUE_WAIT_MARGIN(RemoteCandidate(ep2_ch1())->generation() !=
546 old_remote_candidate2->generation(), 598 old_remote_candidate2->generation(),
547 1000, 1000); 599 1000, 1000);
548 EXPECT_EQ(1u, RemoteCandidate(ep2_ch1())->generation()); 600 EXPECT_EQ(1u, RemoteCandidate(ep2_ch1())->generation());
549 EXPECT_EQ(1u, RemoteCandidate(ep1_ch1())->generation()); 601 EXPECT_EQ(1u, RemoteCandidate(ep1_ch1())->generation());
550 } 602 }
551 603
552 void TestSignalRoleConflict() { 604 void TestSignalRoleConflict() {
553 SetIceProtocol(0, cricket::ICEPROTO_RFC5245);
554 SetIceTiebreaker(0, kTiebreaker1); // Default EP1 is in controlling state. 605 SetIceTiebreaker(0, kTiebreaker1); // Default EP1 is in controlling state.
555 606
556 SetIceProtocol(1, cricket::ICEPROTO_RFC5245);
557 SetIceRole(1, cricket::ICEROLE_CONTROLLING); 607 SetIceRole(1, cricket::ICEROLE_CONTROLLING);
558 SetIceTiebreaker(1, kTiebreaker2); 608 SetIceTiebreaker(1, kTiebreaker2);
559 609
560 // Creating channels with both channels role set to CONTROLLING. 610 // Creating channels with both channels role set to CONTROLLING.
561 CreateChannels(1); 611 CreateChannels(1);
562 // Since both the channels initiated with controlling state and channel2 612 // Since both the channels initiated with controlling state and channel2
563 // has higher tiebreaker value, channel1 should receive SignalRoleConflict. 613 // has higher tiebreaker value, channel1 should receive SignalRoleConflict.
564 EXPECT_TRUE_WAIT(GetRoleConflict(0), 1000); 614 EXPECT_TRUE_WAIT(GetRoleConflict(0), 1000);
565 EXPECT_FALSE(GetRoleConflict(1)); 615 EXPECT_FALSE(GetRoleConflict(1));
566 616
567 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && 617 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
568 ep1_ch1()->writable() && 618 ep1_ch1()->writable() &&
569 ep2_ch1()->readable() && 619 ep2_ch1()->readable() &&
570 ep2_ch1()->writable(), 620 ep2_ch1()->writable(),
571 1000); 621 1000);
572 622
573 EXPECT_TRUE(ep1_ch1()->best_connection() && 623 EXPECT_TRUE(ep1_ch1()->best_connection() &&
574 ep2_ch1()->best_connection()); 624 ep2_ch1()->best_connection());
575 625
576 TestSendRecv(1); 626 TestSendRecv(1);
577 } 627 }
578 628
579 void TestHybridConnectivity(cricket::IceProtocolType proto) {
580 AddAddress(0, kPublicAddrs[0]);
581 AddAddress(1, kPublicAddrs[1]);
582
583 SetAllocationStepDelay(0, kMinimumStepDelay);
584 SetAllocationStepDelay(1, kMinimumStepDelay);
585
586 SetIceRole(0, cricket::ICEROLE_CONTROLLING);
587 SetIceProtocol(0, cricket::ICEPROTO_HYBRID);
588 SetIceTiebreaker(0, kTiebreaker1);
589 SetIceRole(1, cricket::ICEROLE_CONTROLLED);
590 SetIceProtocol(1, proto);
591 SetIceTiebreaker(1, kTiebreaker2);
592
593 CreateChannels(1);
594 // When channel is in hybrid and it's controlling agent, channel will
595 // receive ping request from the remote. Hence connection is readable.
596 // Since channel is in hybrid, it will not send any pings, so no writable
597 // connection. Since channel2 is in controlled state, it will not have
598 // any connections which are readable or writable, as it didn't received
599 // pings (or none) with USE-CANDIDATE attribute.
600 EXPECT_TRUE_WAIT(ep1_ch1()->readable(), 1000);
601
602 // Set real protocol type.
603 ep1_ch1()->SetIceProtocolType(proto);
604
605 // Channel should able to send ping requests and connections become writable
606 // in both directions.
607 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
608 ep2_ch1()->readable() && ep2_ch1()->writable(),
609 1000);
610 EXPECT_TRUE(
611 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
612 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
613 RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
614
615 TestSendRecv(1);
616 DestroyChannels();
617 }
618
619 void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) { 629 void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) {
620 channel->OnSignalingReady(); 630 channel->OnSignalingReady();
621 } 631 }
622 // We pass the candidates directly to the other side. 632 // We pass the candidates directly to the other side.
623 void OnCandidate(cricket::TransportChannelImpl* ch, 633 void OnCandidate(cricket::TransportChannelImpl* ch,
624 const cricket::Candidate& c) { 634 const cricket::Candidate& c) {
625 if (force_relay_ && c.type() != cricket::RELAY_PORT_TYPE) 635 if (force_relay_ && c.type() != cricket::RELAY_PORT_TYPE)
626 return; 636 return;
627 637
628 if (GetEndpoint(ch)->save_candidates_) { 638 if (GetEndpoint(ch)->save_candidates_) {
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after
788 798
789 // Test the matrix of all the connectivity types we expect to see in the wild. 799 // Test the matrix of all the connectivity types we expect to see in the wild.
790 // Just test every combination of the configs in the Config enum. 800 // Just test every combination of the configs in the Config enum.
791 class P2PTransportChannelTest : public P2PTransportChannelTestBase { 801 class P2PTransportChannelTest : public P2PTransportChannelTestBase {
792 protected: 802 protected:
793 static const Result* kMatrix[NUM_CONFIGS][NUM_CONFIGS]; 803 static const Result* kMatrix[NUM_CONFIGS][NUM_CONFIGS];
794 static const Result* kMatrixSharedUfrag[NUM_CONFIGS][NUM_CONFIGS]; 804 static const Result* kMatrixSharedUfrag[NUM_CONFIGS][NUM_CONFIGS];
795 static const Result* kMatrixSharedSocketAsGice[NUM_CONFIGS][NUM_CONFIGS]; 805 static const Result* kMatrixSharedSocketAsGice[NUM_CONFIGS][NUM_CONFIGS];
796 static const Result* kMatrixSharedSocketAsIce[NUM_CONFIGS][NUM_CONFIGS]; 806 static const Result* kMatrixSharedSocketAsIce[NUM_CONFIGS][NUM_CONFIGS];
797 void ConfigureEndpoints(Config config1, Config config2, 807 void ConfigureEndpoints(Config config1, Config config2,
798 int allocator_flags1, int allocator_flags2, 808 int allocator_flags1, int allocator_flags2) {
799 int delay1, int delay2,
800 cricket::IceProtocolType type) {
801 // Ideally we want to use TURN server for both GICE and ICE, but in case
802 // of GICE, TURN server usage is not producing results reliabally.
803 // TODO(mallinath): Remove Relay and use TURN server for all tests.
804 ServerAddresses stun_servers; 809 ServerAddresses stun_servers;
805 stun_servers.insert(kStunAddr); 810 stun_servers.insert(kStunAddr);
806 GetEndpoint(0)->allocator_.reset( 811 GetEndpoint(0)->allocator_.reset(
807 new cricket::BasicPortAllocator(&(GetEndpoint(0)->network_manager_), 812 new cricket::BasicPortAllocator(&(GetEndpoint(0)->network_manager_),
808 stun_servers, 813 stun_servers,
809 rtc::SocketAddress(), rtc::SocketAddress(), 814 rtc::SocketAddress(), rtc::SocketAddress(),
810 rtc::SocketAddress())); 815 rtc::SocketAddress()));
811 GetEndpoint(1)->allocator_.reset( 816 GetEndpoint(1)->allocator_.reset(
812 new cricket::BasicPortAllocator(&(GetEndpoint(1)->network_manager_), 817 new cricket::BasicPortAllocator(&(GetEndpoint(1)->network_manager_),
813 stun_servers, 818 stun_servers,
814 rtc::SocketAddress(), rtc::SocketAddress(), 819 rtc::SocketAddress(), rtc::SocketAddress(),
815 rtc::SocketAddress())); 820 rtc::SocketAddress()));
816 821
817 cricket::RelayServerConfig relay_server(cricket::RELAY_GTURN); 822 cricket::RelayServerConfig relay_server(cricket::RELAY_TURN);
818 if (type == cricket::ICEPROTO_RFC5245) { 823 relay_server.credentials = kRelayCredentials;
819 relay_server.type = cricket::RELAY_TURN; 824 relay_server.ports.push_back(cricket::ProtocolAddress(
820 relay_server.credentials = kRelayCredentials; 825 kTurnUdpIntAddr, cricket::PROTO_UDP, false));
821 relay_server.ports.push_back(cricket::ProtocolAddress(
822 kTurnUdpIntAddr, cricket::PROTO_UDP, false));
823 } else {
824 relay_server.ports.push_back(cricket::ProtocolAddress(
825 kRelayUdpIntAddr, cricket::PROTO_UDP, false));
826 relay_server.ports.push_back(cricket::ProtocolAddress(
827 kRelayTcpIntAddr, cricket::PROTO_TCP, false));
828 relay_server.ports.push_back(cricket::ProtocolAddress(
829 kRelaySslTcpIntAddr, cricket::PROTO_SSLTCP, false));
830 }
831 GetEndpoint(0)->allocator_->AddRelay(relay_server); 826 GetEndpoint(0)->allocator_->AddRelay(relay_server);
832 GetEndpoint(1)->allocator_->AddRelay(relay_server); 827 GetEndpoint(1)->allocator_->AddRelay(relay_server);
833 828
829 int delay = kMinimumStepDelay;
834 ConfigureEndpoint(0, config1); 830 ConfigureEndpoint(0, config1);
835 SetIceProtocol(0, type);
836 SetAllocatorFlags(0, allocator_flags1); 831 SetAllocatorFlags(0, allocator_flags1);
837 SetAllocationStepDelay(0, delay1); 832 SetAllocationStepDelay(0, delay);
838 ConfigureEndpoint(1, config2); 833 ConfigureEndpoint(1, config2);
839 SetIceProtocol(1, type);
840 SetAllocatorFlags(1, allocator_flags2); 834 SetAllocatorFlags(1, allocator_flags2);
841 SetAllocationStepDelay(1, delay2); 835 SetAllocationStepDelay(1, delay);
842 836
843 if (type == cricket::ICEPROTO_RFC5245) { 837 set_clear_remote_candidates_ufrag_pwd(true);
844 set_clear_remote_candidates_ufrag_pwd(true);
845 }
846 } 838 }
847 void ConfigureEndpoint(int endpoint, Config config) { 839 void ConfigureEndpoint(int endpoint, Config config) {
848 switch (config) { 840 switch (config) {
849 case OPEN: 841 case OPEN:
850 AddAddress(endpoint, kPublicAddrs[endpoint]); 842 AddAddress(endpoint, kPublicAddrs[endpoint]);
851 break; 843 break;
852 case NAT_FULL_CONE: 844 case NAT_FULL_CONE:
853 case NAT_ADDR_RESTRICTED: 845 case NAT_ADDR_RESTRICTED:
854 case NAT_PORT_RESTRICTED: 846 case NAT_PORT_RESTRICTED:
855 case NAT_SYMMETRIC: 847 case NAT_SYMMETRIC:
(...skipping 171 matching lines...) Expand 10 before | Expand all | Expand 10 after
1027 /*SC*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT}, 1019 /*SC*/ {PULU, PUSU, PUSU, PURU, PURU, PUSU, PURU, NULL, NULL, LSRS, NULL, LTRT},
1028 /*!U*/ {PTLT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTPT, LSRS, NULL, LTRT}, 1020 /*!U*/ {PTLT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTPT, LSRS, NULL, LTRT},
1029 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTRT, LSRS, NULL, LTRT}, 1021 /*!T*/ {LTRT, NULL, NULL, NULL, NULL, NULL, NULL, PTLT, LTRT, LSRS, NULL, LTRT},
1030 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS}, 1022 /*HT*/ {LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, LSRS, NULL, LSRS},
1031 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}, 1023 /*PR*/ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
1032 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT}, 1024 /*PR*/ {LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LTRT, LSRS, NULL, LTRT},
1033 }; 1025 };
1034 1026
1035 // The actual tests that exercise all the various configurations. 1027 // The actual tests that exercise all the various configurations.
1036 // Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE 1028 // Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE
1037 // Same test case is run in both GICE and ICE mode.
1038 // kDefaultStepDelay - is used for all Gice cases.
1039 // kMinimumStepDelay - is used when both end points have
1040 // PORTALLOCATOR_ENABLE_SHARED_UFRAG flag enabled.
1041 // Technically we should be able to use kMinimumStepDelay irrespective of
1042 // protocol type. But which might need modifications to current result matrices
1043 // for tests in this file.
1044 #define P2P_TEST_DECLARATION(x, y, z) \ 1029 #define P2P_TEST_DECLARATION(x, y, z) \
1045 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceNoneSharedUfrag) { \ 1030 TEST_F(P2PTransportChannelTest, z##Test##x##To##y) { \
1046 ConfigureEndpoints(x, y, kDefaultPortAllocatorFlags, \ 1031 ConfigureEndpoints(x, y, \
1047 kDefaultPortAllocatorFlags, \
1048 kDefaultStepDelay, kDefaultStepDelay, \
1049 cricket::ICEPROTO_GOOGLE); \
1050 if (kMatrix[x][y] != NULL) \
1051 Test(*kMatrix[x][y]); \
1052 else \
1053 LOG(LS_WARNING) << "Not yet implemented"; \
1054 } \
1055 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceP0SharedUfrag) { \
1056 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
1057 kDefaultPortAllocatorFlags, \
1058 kDefaultStepDelay, kDefaultStepDelay, \
1059 cricket::ICEPROTO_GOOGLE); \
1060 if (kMatrix[x][y] != NULL) \
1061 Test(*kMatrix[x][y]); \
1062 else \
1063 LOG(LS_WARNING) << "Not yet implemented"; \
1064 } \
1065 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceP1SharedUfrag) { \
1066 ConfigureEndpoints(x, y, kDefaultPortAllocatorFlags, \
1067 PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
1068 kDefaultStepDelay, kDefaultStepDelay, \
1069 cricket::ICEPROTO_GOOGLE); \
1070 if (kMatrixSharedUfrag[x][y] != NULL) \
1071 Test(*kMatrixSharedUfrag[x][y]); \
1072 else \
1073 LOG(LS_WARNING) << "Not yet implemented"; \
1074 } \
1075 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsGiceBothSharedUfrag) { \
1076 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
1077 PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
1078 kDefaultStepDelay, kDefaultStepDelay, \
1079 cricket::ICEPROTO_GOOGLE); \
1080 if (kMatrixSharedUfrag[x][y] != NULL) \
1081 Test(*kMatrixSharedUfrag[x][y]); \
1082 else \
1083 LOG(LS_WARNING) << "Not yet implemented"; \
1084 } \
1085 TEST_F(P2PTransportChannelTest, \
1086 z##Test##x##To##y##AsGiceBothSharedUfragWithMinimumStepDelay) { \
1087 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
1088 PORTALLOCATOR_ENABLE_SHARED_UFRAG, \
1089 kMinimumStepDelay, kMinimumStepDelay, \
1090 cricket::ICEPROTO_GOOGLE); \
1091 if (kMatrixSharedUfrag[x][y] != NULL) \
1092 Test(*kMatrixSharedUfrag[x][y]); \
1093 else \
1094 LOG(LS_WARNING) << "Not yet implemented"; \
1095 } \
1096 TEST_F(P2PTransportChannelTest, \
1097 z##Test##x##To##y##AsGiceBothSharedUfragSocket) { \
1098 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1099 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \ 1032 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1100 PORTALLOCATOR_ENABLE_SHARED_UFRAG | \ 1033 PORTALLOCATOR_ENABLE_SHARED_SOCKET); \
1101 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1102 kMinimumStepDelay, kMinimumStepDelay, \
1103 cricket::ICEPROTO_GOOGLE); \
1104 if (kMatrixSharedSocketAsGice[x][y] != NULL) \
1105 Test(*kMatrixSharedSocketAsGice[x][y]); \
1106 else \
1107 LOG(LS_WARNING) << "Not yet implemented"; \
1108 } \
1109 TEST_F(P2PTransportChannelTest, z##Test##x##To##y##AsIce) { \
1110 ConfigureEndpoints(x, y, PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1111 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1112 PORTALLOCATOR_ENABLE_SHARED_UFRAG | \
1113 PORTALLOCATOR_ENABLE_SHARED_SOCKET, \
1114 kMinimumStepDelay, kMinimumStepDelay, \
1115 cricket::ICEPROTO_RFC5245); \
1116 if (kMatrixSharedSocketAsIce[x][y] != NULL) \ 1034 if (kMatrixSharedSocketAsIce[x][y] != NULL) \
1117 Test(*kMatrixSharedSocketAsIce[x][y]); \ 1035 Test(*kMatrixSharedSocketAsIce[x][y]); \
1118 else \ 1036 else \
1119 LOG(LS_WARNING) << "Not yet implemented"; \ 1037 LOG(LS_WARNING) << "Not yet implemented"; \
1120 } 1038 }
1121 1039
1122 #define P2P_TEST(x, y) \ 1040 #define P2P_TEST(x, y) \
1123 P2P_TEST_DECLARATION(x, y,) 1041 P2P_TEST_DECLARATION(x, y,)
1124 1042
1125 #define FLAKY_P2P_TEST(x, y) \ 1043 #define FLAKY_P2P_TEST(x, y) \
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1163 P2P_TEST_SET(NAT_DOUBLE_CONE) 1081 P2P_TEST_SET(NAT_DOUBLE_CONE)
1164 P2P_TEST_SET(NAT_SYMMETRIC_THEN_CONE) 1082 P2P_TEST_SET(NAT_SYMMETRIC_THEN_CONE)
1165 P2P_TEST_SET(BLOCK_UDP) 1083 P2P_TEST_SET(BLOCK_UDP)
1166 P2P_TEST_SET(BLOCK_UDP_AND_INCOMING_TCP) 1084 P2P_TEST_SET(BLOCK_UDP_AND_INCOMING_TCP)
1167 P2P_TEST_SET(BLOCK_ALL_BUT_OUTGOING_HTTP) 1085 P2P_TEST_SET(BLOCK_ALL_BUT_OUTGOING_HTTP)
1168 P2P_TEST_SET(PROXY_HTTPS) 1086 P2P_TEST_SET(PROXY_HTTPS)
1169 P2P_TEST_SET(PROXY_SOCKS) 1087 P2P_TEST_SET(PROXY_SOCKS)
1170 1088
1171 // Test that we restart candidate allocation when local ufrag&pwd changed. 1089 // Test that we restart candidate allocation when local ufrag&pwd changed.
1172 // Standard Ice protocol is used. 1090 // Standard Ice protocol is used.
1173 TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeAsIce) { 1091 TEST_F(P2PTransportChannelTest, HandleUfragPwdChange) {
1174 ConfigureEndpoints(OPEN, OPEN, 1092 ConfigureEndpoints(OPEN, OPEN,
1175 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1093 kDefaultPortAllocatorFlags,
1176 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1094 kDefaultPortAllocatorFlags);
1177 kMinimumStepDelay, kMinimumStepDelay,
1178 cricket::ICEPROTO_RFC5245);
1179 CreateChannels(1); 1095 CreateChannels(1);
1180 TestHandleIceUfragPasswordChanged(); 1096 TestHandleIceUfragPasswordChanged();
1181 DestroyChannels(); 1097 DestroyChannels();
1182 }
1183
1184 // Test that we restart candidate allocation when local ufrag&pwd changed.
1185 // Google Ice protocol is used.
1186 TEST_F(P2PTransportChannelTest, HandleUfragPwdChangeAsGice) {
1187 ConfigureEndpoints(OPEN, OPEN,
1188 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1189 PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1190 kDefaultStepDelay, kDefaultStepDelay,
1191 cricket::ICEPROTO_GOOGLE);
1192 CreateChannels(1);
1193 TestHandleIceUfragPasswordChanged();
1194 DestroyChannels();
1195 } 1098 }
1196 1099
1197 // Test the operation of GetStats. 1100 // Test the operation of GetStats.
1198 TEST_F(P2PTransportChannelTest, GetStats) { 1101 TEST_F(P2PTransportChannelTest, GetStats) {
1199 ConfigureEndpoints(OPEN, OPEN, 1102 ConfigureEndpoints(OPEN, OPEN,
1200 kDefaultPortAllocatorFlags, 1103 kDefaultPortAllocatorFlags,
1201 kDefaultPortAllocatorFlags, 1104 kDefaultPortAllocatorFlags);
1202 kDefaultStepDelay, kDefaultStepDelay,
1203 cricket::ICEPROTO_GOOGLE);
1204 CreateChannels(1); 1105 CreateChannels(1);
1205 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1()->readable() && ep1_ch1()->writable() && 1106 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1206 ep2_ch1()->readable() && ep2_ch1()->writable(), 1107 ep2_ch1()->readable() && ep2_ch1()->writable(),
1207 1000, 1000); 1108 1000, 1000);
1208 TestSendRecv(1); 1109 TestSendRecv(1);
1209 cricket::ConnectionInfos infos; 1110 cricket::ConnectionInfos infos;
1210 ASSERT_TRUE(ep1_ch1()->GetStats(&infos)); 1111 ASSERT_TRUE(ep1_ch1()->GetStats(&infos));
1211 ASSERT_EQ(1U, infos.size()); 1112 ASSERT_EQ(1U, infos.size());
1212 EXPECT_TRUE(infos[0].new_connection); 1113 EXPECT_TRUE(infos[0].new_connection);
1213 EXPECT_TRUE(infos[0].best_connection); 1114 EXPECT_TRUE(infos[0].best_connection);
1214 EXPECT_TRUE(infos[0].readable); 1115 EXPECT_TRUE(infos[0].readable);
1215 EXPECT_TRUE(infos[0].writable); 1116 EXPECT_TRUE(infos[0].writable);
1216 EXPECT_FALSE(infos[0].timeout); 1117 EXPECT_FALSE(infos[0].timeout);
1217 EXPECT_EQ(10U, infos[0].sent_total_packets); 1118 EXPECT_EQ(10U, infos[0].sent_total_packets);
1218 EXPECT_EQ(0U, infos[0].sent_discarded_packets); 1119 EXPECT_EQ(0U, infos[0].sent_discarded_packets);
1219 EXPECT_EQ(10 * 36U, infos[0].sent_total_bytes); 1120 EXPECT_EQ(10 * 36U, infos[0].sent_total_bytes);
1220 EXPECT_EQ(10 * 36U, infos[0].recv_total_bytes); 1121 EXPECT_EQ(10 * 36U, infos[0].recv_total_bytes);
1221 EXPECT_GT(infos[0].rtt, 0U); 1122 EXPECT_GT(infos[0].rtt, 0U);
1222 DestroyChannels(); 1123 DestroyChannels();
1223 } 1124 }
1224 1125
1225 // Test that we properly create a connection on a STUN ping from unknown address 1126 // Test that we properly create a connection on a STUN ping from unknown address
1226 // when the signaling is slow. 1127 // when the signaling is slow.
1227 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignaling) { 1128 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignaling) {
1228 ConfigureEndpoints(OPEN, OPEN, 1129 ConfigureEndpoints(OPEN, OPEN,
1229 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1130 kDefaultPortAllocatorFlags,
1230 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1131 kDefaultPortAllocatorFlags);
1231 kDefaultStepDelay, kDefaultStepDelay,
1232 cricket::ICEPROTO_RFC5245);
1233 // Emulate no remote credentials coming in. 1132 // Emulate no remote credentials coming in.
1234 set_clear_remote_candidates_ufrag_pwd(false); 1133 set_clear_remote_candidates_ufrag_pwd(false);
1235 CreateChannels(1); 1134 CreateChannels(1);
1236 // Only have remote credentials come in for ep2, not ep1. 1135 // Only have remote credentials come in for ep2, not ep1.
1237 ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]); 1136 ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]);
1238 1137
1239 // Pause sending ep2's candidates to ep1 until ep1 receives the peer reflexive 1138 // Pause sending ep2's candidates to ep1 until ep1 receives the peer reflexive
1240 // candidate. 1139 // candidate.
1241 PauseCandidates(1); 1140 PauseCandidates(1);
1242 1141
(...skipping 23 matching lines...) Expand all
1266 ep1_ch1()->best_connection()->remote_candidate().type(), 1165 ep1_ch1()->best_connection()->remote_candidate().type(),
1267 2000); 1166 2000);
1268 EXPECT_EQ(best_connection, ep1_ch1()->best_connection()); 1167 EXPECT_EQ(best_connection, ep1_ch1()->best_connection());
1269 DestroyChannels(); 1168 DestroyChannels();
1270 } 1169 }
1271 1170
1272 // Test that we properly create a connection on a STUN ping from unknown address 1171 // Test that we properly create a connection on a STUN ping from unknown address
1273 // when the signaling is slow and the end points are behind NAT. 1172 // when the signaling is slow and the end points are behind NAT.
1274 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignalingWithNAT) { 1173 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignalingWithNAT) {
1275 ConfigureEndpoints(OPEN, NAT_SYMMETRIC, 1174 ConfigureEndpoints(OPEN, NAT_SYMMETRIC,
1276 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1175 kDefaultPortAllocatorFlags,
1277 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1176 kDefaultPortAllocatorFlags);
1278 kDefaultStepDelay, kDefaultStepDelay,
1279 cricket::ICEPROTO_RFC5245);
1280 // Emulate no remote credentials coming in. 1177 // Emulate no remote credentials coming in.
1281 set_clear_remote_candidates_ufrag_pwd(false); 1178 set_clear_remote_candidates_ufrag_pwd(false);
1282 CreateChannels(1); 1179 CreateChannels(1);
1283 // Only have remote credentials come in for ep2, not ep1. 1180 // Only have remote credentials come in for ep2, not ep1.
1284 ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]); 1181 ep2_ch1()->SetRemoteIceCredentials(kIceUfrag[3], kIcePwd[3]);
1285 // Pause sending ep2's candidates to ep1 until ep1 receives the peer reflexive 1182 // Pause sending ep2's candidates to ep1 until ep1 receives the peer reflexive
1286 // candidate. 1183 // candidate.
1287 PauseCandidates(1); 1184 PauseCandidates(1);
1288 1185
1289 // The caller should have the best connection connected to the peer reflexive 1186 // The caller should have the best connection connected to the peer reflexive
(...skipping 21 matching lines...) Expand all
1311 WAIT(ep1_ch1()->writable(), 2000); 1208 WAIT(ep1_ch1()->writable(), 2000);
1312 EXPECT_EQ(ep2_ch1()->best_connection(), best_connection); 1209 EXPECT_EQ(ep2_ch1()->best_connection(), best_connection);
1313 EXPECT_EQ("prflx", ep1_ch1()->best_connection()->remote_candidate().type()); 1210 EXPECT_EQ("prflx", ep1_ch1()->best_connection()->remote_candidate().type());
1314 DestroyChannels(); 1211 DestroyChannels();
1315 } 1212 }
1316 1213
1317 // Test that if remote candidates don't have ufrag and pwd, we still work. 1214 // Test that if remote candidates don't have ufrag and pwd, we still work.
1318 TEST_F(P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd) { 1215 TEST_F(P2PTransportChannelTest, RemoteCandidatesWithoutUfragPwd) {
1319 set_clear_remote_candidates_ufrag_pwd(true); 1216 set_clear_remote_candidates_ufrag_pwd(true);
1320 ConfigureEndpoints(OPEN, OPEN, 1217 ConfigureEndpoints(OPEN, OPEN,
1321 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1218 kDefaultPortAllocatorFlags,
1322 PORTALLOCATOR_ENABLE_SHARED_UFRAG, 1219 kDefaultPortAllocatorFlags);
1323 kMinimumStepDelay, kMinimumStepDelay,
1324 cricket::ICEPROTO_GOOGLE);
1325 CreateChannels(1); 1220 CreateChannels(1);
1326 const cricket::Connection* best_connection = NULL; 1221 const cricket::Connection* best_connection = NULL;
1327 // Wait until the callee's connections are created. 1222 // Wait until the callee's connections are created.
1328 WAIT((best_connection = ep2_ch1()->best_connection()) != NULL, 1000); 1223 WAIT((best_connection = ep2_ch1()->best_connection()) != NULL, 1000);
1329 // Wait to see if they get culled; they shouldn't. 1224 // Wait to see if they get culled; they shouldn't.
1330 WAIT(ep2_ch1()->best_connection() != best_connection, 1000); 1225 WAIT(ep2_ch1()->best_connection() != best_connection, 1000);
1331 EXPECT_TRUE(ep2_ch1()->best_connection() == best_connection); 1226 EXPECT_TRUE(ep2_ch1()->best_connection() == best_connection);
1332 DestroyChannels(); 1227 DestroyChannels();
1333 } 1228 }
1334 1229
1335 // Test that a host behind NAT cannot be reached when incoming_only 1230 // Test that a host behind NAT cannot be reached when incoming_only
1336 // is set to true. 1231 // is set to true.
1337 TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) { 1232 TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
1338 ConfigureEndpoints(NAT_FULL_CONE, OPEN, 1233 ConfigureEndpoints(NAT_FULL_CONE, OPEN,
1339 kDefaultPortAllocatorFlags, 1234 kDefaultPortAllocatorFlags,
1340 kDefaultPortAllocatorFlags, 1235 kDefaultPortAllocatorFlags);
1341 kDefaultStepDelay, kDefaultStepDelay,
1342 cricket::ICEPROTO_GOOGLE);
1343 1236
1344 SetAllocatorFlags(0, kOnlyLocalPorts); 1237 SetAllocatorFlags(0, kOnlyLocalPorts);
1345 CreateChannels(1); 1238 CreateChannels(1);
1346 ep1_ch1()->set_incoming_only(true); 1239 ep1_ch1()->set_incoming_only(true);
1347 1240
1348 // Pump for 1 second and verify that the channels are not connected. 1241 // Pump for 1 second and verify that the channels are not connected.
1349 rtc::Thread::Current()->ProcessMessages(1000); 1242 rtc::Thread::Current()->ProcessMessages(1000);
1350 1243
1351 EXPECT_FALSE(ep1_ch1()->readable()); 1244 EXPECT_FALSE(ep1_ch1()->readable());
1352 EXPECT_FALSE(ep1_ch1()->writable()); 1245 EXPECT_FALSE(ep1_ch1()->writable());
1353 EXPECT_FALSE(ep2_ch1()->readable()); 1246 EXPECT_FALSE(ep2_ch1()->readable());
1354 EXPECT_FALSE(ep2_ch1()->writable()); 1247 EXPECT_FALSE(ep2_ch1()->writable());
1355 1248
1356 DestroyChannels(); 1249 DestroyChannels();
1357 } 1250 }
1358 1251
1359 // Test that a peer behind NAT can connect to a peer that has 1252 // Test that a peer behind NAT can connect to a peer that has
1360 // incoming_only flag set. 1253 // incoming_only flag set.
1361 TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) { 1254 TEST_F(P2PTransportChannelTest, IncomingOnlyOpen) {
1362 ConfigureEndpoints(OPEN, NAT_FULL_CONE, 1255 ConfigureEndpoints(OPEN, NAT_FULL_CONE,
1363 kDefaultPortAllocatorFlags, 1256 kDefaultPortAllocatorFlags,
1364 kDefaultPortAllocatorFlags, 1257 kDefaultPortAllocatorFlags);
1365 kDefaultStepDelay, kDefaultStepDelay,
1366 cricket::ICEPROTO_GOOGLE);
1367 1258
1368 SetAllocatorFlags(0, kOnlyLocalPorts); 1259 SetAllocatorFlags(0, kOnlyLocalPorts);
1369 CreateChannels(1); 1260 CreateChannels(1);
1370 ep1_ch1()->set_incoming_only(true); 1261 ep1_ch1()->set_incoming_only(true);
1371 1262
1372 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL && ep2_ch1() != NULL && 1263 EXPECT_TRUE_WAIT_MARGIN(ep1_ch1() != NULL && ep2_ch1() != NULL &&
1373 ep1_ch1()->readable() && ep1_ch1()->writable() && 1264 ep1_ch1()->readable() && ep1_ch1()->writable() &&
1374 ep2_ch1()->readable() && ep2_ch1()->writable(), 1265 ep2_ch1()->readable() && ep2_ch1()->writable(),
1375 1000, 1000); 1266 1000, 1000);
1376 1267
1377 DestroyChannels(); 1268 DestroyChannels();
1378 } 1269 }
1379 1270
1380 TEST_F(P2PTransportChannelTest, TestTcpConnectionsFromActiveToPassive) { 1271 TEST_F(P2PTransportChannelTest, TestTcpConnectionsFromActiveToPassive) {
1381 AddAddress(0, kPublicAddrs[0]); 1272 AddAddress(0, kPublicAddrs[0]);
1382 AddAddress(1, kPublicAddrs[1]); 1273 AddAddress(1, kPublicAddrs[1]);
1383 1274
1384 SetAllocationStepDelay(0, kMinimumStepDelay); 1275 SetAllocationStepDelay(0, kMinimumStepDelay);
1385 SetAllocationStepDelay(1, kMinimumStepDelay); 1276 SetAllocationStepDelay(1, kMinimumStepDelay);
1386 1277
1387 int kOnlyLocalTcpPorts = cricket::PORTALLOCATOR_DISABLE_UDP | 1278 int kOnlyLocalTcpPorts = cricket::PORTALLOCATOR_DISABLE_UDP |
1388 cricket::PORTALLOCATOR_DISABLE_STUN | 1279 cricket::PORTALLOCATOR_DISABLE_STUN |
1389 cricket::PORTALLOCATOR_DISABLE_RELAY | 1280 cricket::PORTALLOCATOR_DISABLE_RELAY;
1390 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG;
1391 // Disable all protocols except TCP. 1281 // Disable all protocols except TCP.
1392 SetAllocatorFlags(0, kOnlyLocalTcpPorts); 1282 SetAllocatorFlags(0, kOnlyLocalTcpPorts);
1393 SetAllocatorFlags(1, kOnlyLocalTcpPorts); 1283 SetAllocatorFlags(1, kOnlyLocalTcpPorts);
1394 1284
1395 SetAllowTcpListen(0, true); // actpass. 1285 SetAllowTcpListen(0, true); // actpass.
1396 SetAllowTcpListen(1, false); // active. 1286 SetAllowTcpListen(1, false); // active.
1397 1287
1398 CreateChannels(1); 1288 CreateChannels(1);
1399 1289
1400 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() && 1290 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
(...skipping 20 matching lines...) Expand all
1421 TestSignalRoleConflict(); 1311 TestSignalRoleConflict();
1422 } 1312 }
1423 1313
1424 // Tests that the ice configs (protocol, tiebreaker and role) can be passed 1314 // Tests that the ice configs (protocol, tiebreaker and role) can be passed
1425 // down to ports. 1315 // down to ports.
1426 TEST_F(P2PTransportChannelTest, TestIceConfigWillPassDownToPort) { 1316 TEST_F(P2PTransportChannelTest, TestIceConfigWillPassDownToPort) {
1427 AddAddress(0, kPublicAddrs[0]); 1317 AddAddress(0, kPublicAddrs[0]);
1428 AddAddress(1, kPublicAddrs[1]); 1318 AddAddress(1, kPublicAddrs[1]);
1429 1319
1430 SetIceRole(0, cricket::ICEROLE_CONTROLLING); 1320 SetIceRole(0, cricket::ICEROLE_CONTROLLING);
1431 SetIceProtocol(0, cricket::ICEPROTO_GOOGLE);
1432 SetIceTiebreaker(0, kTiebreaker1); 1321 SetIceTiebreaker(0, kTiebreaker1);
1433 SetIceRole(1, cricket::ICEROLE_CONTROLLING); 1322 SetIceRole(1, cricket::ICEROLE_CONTROLLING);
1434 SetIceProtocol(1, cricket::ICEPROTO_RFC5245);
1435 SetIceTiebreaker(1, kTiebreaker2); 1323 SetIceTiebreaker(1, kTiebreaker2);
1436 1324
1437 CreateChannels(1); 1325 CreateChannels(1);
1438 1326
1439 EXPECT_EQ_WAIT(2u, ep1_ch1()->ports().size(), 1000); 1327 EXPECT_EQ_WAIT(2u, ep1_ch1()->ports().size(), 1000);
1440 1328
1441 const std::vector<cricket::PortInterface *> ports_before = ep1_ch1()->ports(); 1329 const std::vector<cricket::PortInterface *> ports_before = ep1_ch1()->ports();
1442 for (size_t i = 0; i < ports_before.size(); ++i) { 1330 for (size_t i = 0; i < ports_before.size(); ++i) {
1443 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, ports_before[i]->GetIceRole()); 1331 EXPECT_EQ(cricket::ICEROLE_CONTROLLING, ports_before[i]->GetIceRole());
1444 EXPECT_EQ(cricket::ICEPROTO_GOOGLE, ports_before[i]->IceProtocol());
1445 EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker()); 1332 EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker());
1446 } 1333 }
1447 1334
1448 ep1_ch1()->SetIceRole(cricket::ICEROLE_CONTROLLED); 1335 ep1_ch1()->SetIceRole(cricket::ICEROLE_CONTROLLED);
1449 ep1_ch1()->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
1450 ep1_ch1()->SetIceTiebreaker(kTiebreaker2); 1336 ep1_ch1()->SetIceTiebreaker(kTiebreaker2);
1451 1337
1452 const std::vector<cricket::PortInterface *> ports_after = ep1_ch1()->ports(); 1338 const std::vector<cricket::PortInterface *> ports_after = ep1_ch1()->ports();
1453 for (size_t i = 0; i < ports_after.size(); ++i) { 1339 for (size_t i = 0; i < ports_after.size(); ++i) {
1454 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, ports_before[i]->GetIceRole()); 1340 EXPECT_EQ(cricket::ICEROLE_CONTROLLED, ports_before[i]->GetIceRole());
1455 EXPECT_EQ(cricket::ICEPROTO_RFC5245, ports_before[i]->IceProtocol());
1456 // SetIceTiebreaker after Connect() has been called will fail. So expect the 1341 // SetIceTiebreaker after Connect() has been called will fail. So expect the
1457 // original value. 1342 // original value.
1458 EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker()); 1343 EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker());
1459 } 1344 }
1460 1345
1461 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && 1346 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
1462 ep1_ch1()->writable() && 1347 ep1_ch1()->writable() &&
1463 ep2_ch1()->readable() && 1348 ep2_ch1()->readable() &&
1464 ep2_ch1()->writable(), 1349 ep2_ch1()->writable(),
1465 1000); 1350 1000);
1466 1351
1467 EXPECT_TRUE(ep1_ch1()->best_connection() && 1352 EXPECT_TRUE(ep1_ch1()->best_connection() &&
1468 ep2_ch1()->best_connection()); 1353 ep2_ch1()->best_connection());
1469 1354
1470 TestSendRecv(1); 1355 TestSendRecv(1);
1471 DestroyChannels(); 1356 DestroyChannels();
1472 } 1357 }
1473 1358
1474 // This test verifies channel can handle ice messages when channel is in
1475 // hybrid mode.
1476 TEST_F(P2PTransportChannelTest, TestConnectivityBetweenHybridandIce) {
1477 TestHybridConnectivity(cricket::ICEPROTO_RFC5245);
1478 }
1479
1480 // This test verifies channel can handle Gice messages when channel is in
1481 // hybrid mode.
1482 TEST_F(P2PTransportChannelTest, TestConnectivityBetweenHybridandGice) {
1483 TestHybridConnectivity(cricket::ICEPROTO_GOOGLE);
1484 }
1485
1486 // Verify that we can set DSCP value and retrieve properly from P2PTC. 1359 // Verify that we can set DSCP value and retrieve properly from P2PTC.
1487 TEST_F(P2PTransportChannelTest, TestDefaultDscpValue) { 1360 TEST_F(P2PTransportChannelTest, TestDefaultDscpValue) {
1488 AddAddress(0, kPublicAddrs[0]); 1361 AddAddress(0, kPublicAddrs[0]);
1489 AddAddress(1, kPublicAddrs[1]); 1362 AddAddress(1, kPublicAddrs[1]);
1490 1363
1491 CreateChannels(1); 1364 CreateChannels(1);
1492 EXPECT_EQ(rtc::DSCP_NO_CHANGE, 1365 EXPECT_EQ(rtc::DSCP_NO_CHANGE,
1493 GetEndpoint(0)->cd1_.ch_->DefaultDscpValue()); 1366 GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
1494 EXPECT_EQ(rtc::DSCP_NO_CHANGE, 1367 EXPECT_EQ(rtc::DSCP_NO_CHANGE,
1495 GetEndpoint(1)->cd1_.ch_->DefaultDscpValue()); 1368 GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
1536 RemoteCandidate(ep1_ch1())->address().EqualIPs(kIPv6PublicAddrs[1])); 1409 RemoteCandidate(ep1_ch1())->address().EqualIPs(kIPv6PublicAddrs[1]));
1537 1410
1538 TestSendRecv(1); 1411 TestSendRecv(1);
1539 DestroyChannels(); 1412 DestroyChannels();
1540 } 1413 }
1541 1414
1542 // Testing forceful TURN connections. 1415 // Testing forceful TURN connections.
1543 TEST_F(P2PTransportChannelTest, TestForceTurn) { 1416 TEST_F(P2PTransportChannelTest, TestForceTurn) {
1544 ConfigureEndpoints(NAT_PORT_RESTRICTED, NAT_SYMMETRIC, 1417 ConfigureEndpoints(NAT_PORT_RESTRICTED, NAT_SYMMETRIC,
1545 kDefaultPortAllocatorFlags | 1418 kDefaultPortAllocatorFlags |
1546 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | 1419 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET,
1547 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1548 kDefaultPortAllocatorFlags | 1420 kDefaultPortAllocatorFlags |
1549 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET | 1421 cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
1550 cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG,
1551 kDefaultStepDelay, kDefaultStepDelay,
1552 cricket::ICEPROTO_RFC5245);
1553 set_force_relay(true); 1422 set_force_relay(true);
1554 1423
1555 SetAllocationStepDelay(0, kMinimumStepDelay); 1424 SetAllocationStepDelay(0, kMinimumStepDelay);
1556 SetAllocationStepDelay(1, kMinimumStepDelay); 1425 SetAllocationStepDelay(1, kMinimumStepDelay);
1557 1426
1558 CreateChannels(1); 1427 CreateChannels(1);
1559 1428
1560 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && 1429 EXPECT_TRUE_WAIT(ep1_ch1()->readable() &&
1561 ep1_ch1()->writable() && 1430 ep1_ch1()->writable() &&
1562 ep2_ch1()->readable() && 1431 ep2_ch1()->readable() &&
1563 ep2_ch1()->writable(), 1432 ep2_ch1()->writable(),
1564 1000); 1433 2000);
1565 1434
1566 EXPECT_TRUE(ep1_ch1()->best_connection() && 1435 EXPECT_TRUE(ep1_ch1()->best_connection() &&
1567 ep2_ch1()->best_connection()); 1436 ep2_ch1()->best_connection());
1568 1437
1569 EXPECT_EQ("relay", RemoteCandidate(ep1_ch1())->type()); 1438 EXPECT_EQ("relay", RemoteCandidate(ep1_ch1())->type());
1570 EXPECT_EQ("relay", LocalCandidate(ep1_ch1())->type()); 1439 EXPECT_EQ("relay", LocalCandidate(ep1_ch1())->type());
1571 EXPECT_EQ("relay", RemoteCandidate(ep2_ch1())->type()); 1440 EXPECT_EQ("relay", RemoteCandidate(ep2_ch1())->type());
1572 EXPECT_EQ("relay", LocalCandidate(ep2_ch1())->type()); 1441 EXPECT_EQ("relay", LocalCandidate(ep2_ch1())->type());
1573 1442
1574 TestSendRecv(1); 1443 TestSendRecv(1);
(...skipping 23 matching lines...) Expand all
1598 AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]); 1467 AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
1599 nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint], 1468 nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
1600 static_cast<rtc::NATType>(config - NAT_FULL_CONE))->AddClient( 1469 static_cast<rtc::NATType>(config - NAT_FULL_CONE))->AddClient(
1601 kCascadedPrivateAddrs[endpoint]); 1470 kCascadedPrivateAddrs[endpoint]);
1602 } 1471 }
1603 } 1472 }
1604 }; 1473 };
1605 1474
1606 TEST_F(P2PTransportChannelSameNatTest, TestConesBehindSameCone) { 1475 TEST_F(P2PTransportChannelSameNatTest, TestConesBehindSameCone) {
1607 ConfigureEndpoints(NAT_FULL_CONE, NAT_FULL_CONE, NAT_FULL_CONE); 1476 ConfigureEndpoints(NAT_FULL_CONE, NAT_FULL_CONE, NAT_FULL_CONE);
1608 Test(kLocalUdpToStunUdp); 1477 Test(P2PTransportChannelTestBase::Result(
1478 "prflx", "udp", "stun", "udp",
1479 "stun", "udp", "prflx", "udp", 1000));
1609 } 1480 }
1610 1481
1611 // Test what happens when we have multiple available pathways. 1482 // Test what happens when we have multiple available pathways.
1612 // In the future we will try different RTTs and configs for the different 1483 // In the future we will try different RTTs and configs for the different
1613 // interfaces, so that we can simulate a user with Ethernet and VPN networks. 1484 // interfaces, so that we can simulate a user with Ethernet and VPN networks.
1614 class P2PTransportChannelMultihomedTest : public P2PTransportChannelTestBase { 1485 class P2PTransportChannelMultihomedTest : public P2PTransportChannelTestBase {
1615 }; 1486 };
1616 1487
1617 // Test that we can establish connectivity when both peers are multihomed. 1488 // Test that we can establish connectivity when both peers are multihomed.
1618 TEST_F(P2PTransportChannelMultihomedTest, DISABLED_TestBasic) { 1489 TEST_F(P2PTransportChannelMultihomedTest, DISABLED_TestBasic) {
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
1657 // when we lose writability. 1528 // when we lose writability.
1658 EXPECT_TRUE_WAIT( 1529 EXPECT_TRUE_WAIT(
1659 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() && 1530 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1660 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) && 1531 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1661 RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]), 1532 RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]),
1662 3000); 1533 3000);
1663 1534
1664 DestroyChannels(); 1535 DestroyChannels();
1665 } 1536 }
1666 1537
1538 /*
1539
1540 TODO(pthatcher): Once have a way to handle network interfaces changes
1541 without signalling an ICE restart, put a test like this back. In the
1542 mean time, this test only worked for GICE. With ICE, it's currently
1543 not possible without an ICE restart.
1544
1667 // Test that we can switch links in a coordinated fashion. 1545 // Test that we can switch links in a coordinated fashion.
1668 TEST_F(P2PTransportChannelMultihomedTest, TestDrain) { 1546 TEST_F(P2PTransportChannelMultihomedTest, TestDrain) {
1669 AddAddress(0, kPublicAddrs[0]); 1547 AddAddress(0, kPublicAddrs[0]);
1670 AddAddress(1, kPublicAddrs[1]); 1548 AddAddress(1, kPublicAddrs[1]);
1671 // Use only local ports for simplicity. 1549 // Use only local ports for simplicity.
1672 SetAllocatorFlags(0, kOnlyLocalPorts); 1550 SetAllocatorFlags(0, kOnlyLocalPorts);
1673 SetAllocatorFlags(1, kOnlyLocalPorts); 1551 SetAllocatorFlags(1, kOnlyLocalPorts);
1674 1552
1675 // Create channels and let them go writable, as usual. 1553 // Create channels and let them go writable, as usual.
1676 CreateChannels(1); 1554 CreateChannels(1);
1677 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() && 1555 EXPECT_TRUE_WAIT(ep1_ch1()->readable() && ep1_ch1()->writable() &&
1678 ep2_ch1()->readable() && ep2_ch1()->writable(), 1556 ep2_ch1()->readable() && ep2_ch1()->writable(),
1679 1000); 1557 1000);
1680 EXPECT_TRUE( 1558 EXPECT_TRUE(
1681 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() && 1559 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1682 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) && 1560 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1683 RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1])); 1561 RemoteCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[1]));
1684 1562
1563
1685 // Remove the public interface, add the alternate interface, and allocate 1564 // Remove the public interface, add the alternate interface, and allocate
1686 // a new generation of candidates for the new interface (via Connect()). 1565 // a new generation of candidates for the new interface (via Connect()).
1687 LOG(LS_INFO) << "Draining..."; 1566 LOG(LS_INFO) << "Draining...";
1688 AddAddress(1, kAlternateAddrs[1]); 1567 AddAddress(1, kAlternateAddrs[1]);
1689 RemoveAddress(1, kPublicAddrs[1]); 1568 RemoveAddress(1, kPublicAddrs[1]);
1690 ep2_ch1()->Connect(); 1569 ep2_ch1()->Connect();
1691 1570
1692 // We should switch over to use the alternate address after 1571 // We should switch over to use the alternate address after
1693 // an exchange of pings. 1572 // an exchange of pings.
1694 EXPECT_TRUE_WAIT( 1573 EXPECT_TRUE_WAIT(
1695 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() && 1574 ep1_ch1()->best_connection() && ep2_ch1()->best_connection() &&
1696 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) && 1575 LocalCandidate(ep1_ch1())->address().EqualIPs(kPublicAddrs[0]) &&
1697 RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]), 1576 RemoteCandidate(ep1_ch1())->address().EqualIPs(kAlternateAddrs[1]),
1698 3000); 1577 3000);
1699 1578
1700 DestroyChannels(); 1579 DestroyChannels();
1701 } 1580 }
1702 1581
1582 */
1583
1703 // A collection of tests which tests a single P2PTransportChannel by sending 1584 // A collection of tests which tests a single P2PTransportChannel by sending
1704 // pings. 1585 // pings.
1705 class P2PTransportChannelPingTest : public testing::Test, 1586 class P2PTransportChannelPingTest : public testing::Test,
1706 public sigslot::has_slots<> { 1587 public sigslot::has_slots<> {
1707 public: 1588 public:
1708 P2PTransportChannelPingTest() 1589 P2PTransportChannelPingTest()
1709 : pss_(new rtc::PhysicalSocketServer), 1590 : pss_(new rtc::PhysicalSocketServer),
1710 vss_(new rtc::VirtualSocketServer(pss_.get())), 1591 vss_(new rtc::VirtualSocketServer(pss_.get())),
1711 ss_scope_(vss_.get()) {} 1592 ss_scope_(vss_.get()) {}
1712 1593
1713 protected: 1594 protected:
1714 void PrepareChannel(cricket::P2PTransportChannel* ch) { 1595 void PrepareChannel(cricket::P2PTransportChannel* ch) {
1715 ch->SignalRequestSignaling.connect( 1596 ch->SignalRequestSignaling.connect(
1716 this, &P2PTransportChannelPingTest::OnChannelRequestSignaling); 1597 this, &P2PTransportChannelPingTest::OnChannelRequestSignaling);
1717 ch->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
1718 ch->SetIceRole(cricket::ICEROLE_CONTROLLING); 1598 ch->SetIceRole(cricket::ICEROLE_CONTROLLING);
1719 ch->SetIceCredentials(kIceUfrag[0], kIcePwd[0]); 1599 ch->SetIceCredentials(kIceUfrag[0], kIcePwd[0]);
1720 ch->SetRemoteIceCredentials(kIceUfrag[1], kIcePwd[1]); 1600 ch->SetRemoteIceCredentials(kIceUfrag[1], kIcePwd[1]);
1721 } 1601 }
1722 1602
1723 void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) { 1603 void OnChannelRequestSignaling(cricket::TransportChannelImpl* channel) {
1724 channel->OnSignalingReady(); 1604 channel->OnSignalingReady();
1725 } 1605 }
1726 1606
1727 cricket::Candidate CreateCandidate(const std::string& ip, 1607 cricket::Candidate CreateCandidate(const std::string& ip,
(...skipping 327 matching lines...) Expand 10 before | Expand all | Expand 10 after
2055 conn3->ReceivedPingResponse(); // Become writable. 1935 conn3->ReceivedPingResponse(); // Become writable.
2056 EXPECT_EQ(conn3, ch.best_connection()); 1936 EXPECT_EQ(conn3, ch.best_connection());
2057 1937
2058 // Now another data packet will not switch the best connection because the 1938 // Now another data packet will not switch the best connection because the
2059 // best connection was nominated by the controlling side. 1939 // best connection was nominated by the controlling side.
2060 conn2->ReceivedPing(); 1940 conn2->ReceivedPing();
2061 conn2->ReceivedPingResponse(); 1941 conn2->ReceivedPingResponse();
2062 conn2->OnReadPacket("XYZ", 3, rtc::CreatePacketTime(0)); 1942 conn2->OnReadPacket("XYZ", 3, rtc::CreatePacketTime(0));
2063 EXPECT_EQ(conn3, ch.best_connection()); 1943 EXPECT_EQ(conn3, ch.best_connection());
2064 } 1944 }
OLDNEW
« no previous file with comments | « webrtc/p2p/base/p2ptransportchannel.cc ('k') | webrtc/p2p/base/port.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698