Accept remote offers with current DTLS role, rather than "actpass".

webrtc/p2p/base/transportcontroller_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 254 matching lines @@
   // change its role/tie-breaker when it does an ICE restart.
   transport2->fake_ice_transport()->SignalRoleConflict(
       transport2->fake_ice_transport());
   EXPECT_EQ(ICEROLE_CONTROLLING,
             transport1->fake_ice_transport()->GetIceRole());
   EXPECT_EQ(ICEROLE_CONTROLLING,
             transport2->fake_ice_transport()->GetIceRole());
 }
 
 TEST_F(TransportControllerTest, TestGetSslRole) {
-  FakeDtlsTransport* transport = CreateFakeDtlsTransport("audio", 1);
-  ASSERT_NE(nullptr, transport);
-  ASSERT_TRUE(transport->SetSslRole(rtc::SSL_CLIENT));
   rtc::SSLRole role;
+  CreateFakeDtlsTransport("audio", 1);
+
+  // Should return false before role has been negotiated.
+  EXPECT_FALSE(transport_controller_->GetSslRole("audio", &role));
+
+  // To negotiate an SSL role, need to set a local certificate, and
+  // local/remote transport descriptions with DTLS info.
+  rtc::scoped_refptr<rtc::RTCCertificate> certificate =
+      rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
+          rtc::SSLIdentity::Generate("testing", rtc::KT_ECDSA)));
+  std::unique_ptr<rtc::SSLFingerprint> fingerprint(
+      rtc::SSLFingerprint::CreateFromCertificate(certificate));
+  transport_controller_->SetLocalCertificate(certificate);
+
+  // Set the same fingerprint on both sides since the remote fingerprint
+  // doesn't really matter for this test.
+  TransportDescription local_desc(std::vector<std::string>(), kIceUfrag1,
+                                  kIcePwd1, ICEMODE_FULL,
+                                  CONNECTIONROLE_ACTPASS, fingerprint.get());
+  TransportDescription remote_desc(std::vector<std::string>(), kIceUfrag2,
+                                   kIcePwd2, ICEMODE_FULL,
+                                   CONNECTIONROLE_ACTIVE, fingerprint.get());
+  std::string err;
+  EXPECT_TRUE(transport_controller_->SetLocalTransportDescription(
+      "audio", local_desc, cricket::CA_OFFER, &err));
+  EXPECT_TRUE(transport_controller_->SetRemoteTransportDescription(
+      "audio", remote_desc, cricket::CA_ANSWER, &err));
+
+  // Finally we can get the role. Should be "server" since the remote
+  // endpoint's role was "active".
+  EXPECT_TRUE(transport_controller_->GetSslRole("audio", &role));
+  EXPECT_EQ(rtc::SSL_SERVER, role);
+
+  // Lastly, test that GetSslRole returns false for a nonexistent transport.
   EXPECT_FALSE(transport_controller_->GetSslRole("video", &role));
-  EXPECT_TRUE(transport_controller_->GetSslRole("audio", &role));

[Taylor Brandstetter, 2017/03/23 03:37:10]

This test was just succeeding by accident before, because the default value
returned (even if the role wasn't negotiated yet) was SSL_CLIENT.

-  EXPECT_EQ(rtc::SSL_CLIENT, role);
 }
 
 TEST_F(TransportControllerTest, TestSetAndGetLocalCertificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate1 =
       rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session1", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> certificate2 =
       rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
           rtc::SSLIdentity::Generate("session2", rtc::KT_DEFAULT)));
   rtc::scoped_refptr<rtc::RTCCertificate> returned_certificate;
@@ skipping 548 matching lines @@
   ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
       "audio", ice_restart_local_desc, CA_OFFER, nullptr));
   ASSERT_TRUE(transport_controller_->SetLocalTransportDescription(
       "video", local_desc, CA_OFFER, nullptr));
   // NeedsIceRestart should still be true for video.
   EXPECT_FALSE(transport_controller_->NeedsIceRestart("audio"));
   EXPECT_TRUE(transport_controller_->NeedsIceRestart("video"));
 }
 
 }  // namespace cricket {