Modify PeerConnection for end-to-end QuicDataChannel usage

webrtc/p2p/quic/quictransportchannel_unittest.cc

 /*
  *  Copyright 2016 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.
  */
 
 #include "webrtc/p2p/quic/quictransportchannel.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sslfingerprint.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 
 using cricket::ConnectionRole;
 using cricket::IceRole;
 using cricket::QuicTransportChannel;
 using cricket::TransportChannel;
 using cricket::TransportDescription;
 
 // Timeout in milliseconds for asynchronous operations in unit tests.
 static const int kTimeoutMs = 1000;
 
 // Export keying material parameters.
 static const char kExporterLabel[] = "label";
 static const uint8_t kExporterContext[] = "context";
 static const size_t kExporterContextLength = sizeof(kExporterContext);
 static const size_t kOutputKeyLength = 20;
 
 // Packet size for SRTP.
 static const size_t kPacketSize = 100;
 
 // Indicates ICE channel has no write error.
 static const int kNoWriteError = 0;
 
 // ICE parameters.
-static const char kIceUfrag[] = "TESTICEUFRAG0001";
-static const char kIcePwd[] = "TESTICEPWD00000000000001";
+static const char kIceUfrag1[] = "TESTICEUFRAG0001";
+static const char kIcePwd1[] = "TESTICEPWD00000000000001";
+static const char kIceUfrag2[] = "TESTICEUFRAG0002";
+static const char kIcePwd2[] = "TESTICEPWD00000000000002";
 
 // QUIC packet parameters.
 static const net::IPAddress kIpAddress(0, 0, 0, 0);
 static const net::IPEndPoint kIpEndpoint(kIpAddress, 0);
 
 // Detects incoming RTP packets.
 static bool IsRtpLeadByte(uint8_t b) {
   return (b & 0xC0) == 0x80;
 }
 
@@ skipping 61 matching lines @@
   // Generates ICE credentials and passes them to |quic_channel_|.
   void SetIceParameters(IceRole local_ice_role,
                         ConnectionRole local_connection_role,
                         ConnectionRole remote_connection_role,
                         rtc::SSLFingerprint* remote_fingerprint) {
     quic_channel_.SetIceRole(local_ice_role);
     quic_channel_.SetIceTiebreaker(
         (local_ice_role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
 
     TransportDescription local_desc(
-        std::vector<std::string>(), kIceUfrag, kIcePwd, cricket::ICEMODE_FULL,
+        std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_FULL,
         local_connection_role, local_fingerprint_.get());
     TransportDescription remote_desc(
-        std::vector<std::string>(), kIceUfrag, kIcePwd, cricket::ICEMODE_FULL,
+        std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_FULL,
         remote_connection_role, remote_fingerprint);
 
     quic_channel_.SetIceCredentials(local_desc.ice_ufrag, local_desc.ice_pwd);
     quic_channel_.SetRemoteIceCredentials(remote_desc.ice_ufrag,
                                           remote_desc.ice_pwd);
   }
 
   // Creates fingerprint from certificate.
   rtc::SSLFingerprint* CreateFingerprint(rtc::RTCCertificate* cert) {
     std::string digest_algorithm;
@@ skipping 149 matching lines @@
 };
 
 // Test that the QUIC channel passes ICE parameters to the underlying ICE
 // channel.
 TEST_F(QuicTransportChannelTest, ChannelSetupIce) {
   SetIceAndCryptoParameters(rtc::SSL_CLIENT, rtc::SSL_SERVER);
   FailableTransportChannel* channel1 = peer1_.ice_channel();
   FailableTransportChannel* channel2 = peer2_.ice_channel();
   EXPECT_EQ(cricket::ICEROLE_CONTROLLED, channel1->GetIceRole());
   EXPECT_EQ(2u, channel1->IceTiebreaker());
-  EXPECT_EQ(kIceUfrag, channel1->ice_ufrag());
-  EXPECT_EQ(kIcePwd, channel1->ice_pwd());
+  EXPECT_EQ(kIceUfrag1, channel1->ice_ufrag());
+  EXPECT_EQ(kIcePwd1, channel1->ice_pwd());
   EXPECT_EQ(cricket::ICEROLE_CONTROLLING, channel2->GetIceRole());
   EXPECT_EQ(1u, channel2->IceTiebreaker());
 }
 
 // Test that export keying material generates identical keys for both peers
 // after the QUIC handshake.
 TEST_F(QuicTransportChannelTest, ExportKeyingMaterial) {
   Connect();
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   uint8_t key1[kOutputKeyLength];
@@ skipping 166 matching lines @@
 
 // Test that if the ICE channel becomes receiving before the QUIC channel is
 // connected, then the QUIC channel becomes receiving.
 TEST_F(QuicTransportChannelTest, IceReceivingBeforeConnected) {
   Connect();
   peer1_.ice_channel()->SetReceiving(true);
   ASSERT_TRUE(peer1_.ice_channel()->receiving());
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   EXPECT_TRUE(peer1_.quic_channel()->receiving());
 }
+
+// Test that the Transport base class applies local and remote descriptions to
+// the QUIC channel.
+TEST_F(QuicTransportChannelTest, SetLocalAndRemoteTransportDescription) {
+  QuicTransportChannel* quic_channel = peer1_.quic_channel();
+  // Set the local description.
+  rtc::SSLFingerprint* local_fingerprint = peer1_.local_fingerprint().get();
+  TransportDescription local_desc(
+      std::vector<std::string>(), kIceUfrag1, kIcePwd1, cricket::ICEMODE_FULL,
+      cricket::CONNECTIONROLE_ACTPASS, local_fingerprint);
+  ASSERT_TRUE(quic_channel->SetLocalTransportDescription(
+      local_desc, cricket::CA_OFFER, nullptr));
+  const TransportDescription* transport_local_desc =
+      quic_channel->local_description_for_test();
+  EXPECT_EQ(kIceUfrag1, transport_local_desc->ice_ufrag);
+  EXPECT_EQ(kIcePwd1, transport_local_desc->ice_pwd);
+  EXPECT_EQ(*local_fingerprint, *transport_local_desc->identity_fingerprint);
+  // NegotiateTransportDescription was not called yet. The SSL role should
+  // not be set and neither should the remote fingerprint.
+  rtc::scoped_ptr<rtc::SSLRole> role(new rtc::SSLRole());
+  EXPECT_FALSE(quic_channel->GetSslRole(role.get()));
+  // Set the remote description.
+  rtc::SSLFingerprint* remote_fingerprint = peer2_.local_fingerprint().get();
+  TransportDescription remote_desc(
+      std::vector<std::string>(), kIceUfrag2, kIcePwd2, cricket::ICEMODE_FULL,
+      cricket::CONNECTIONROLE_PASSIVE, remote_fingerprint);
+  ASSERT_TRUE(quic_channel->SetRemoteTransportDescription(
+      remote_desc, cricket::CA_ANSWER, nullptr));
+  const TransportDescription* transport_remote_desc =
+      quic_channel->remote_description_for_test();
+  EXPECT_EQ(kIceUfrag2, transport_remote_desc->ice_ufrag);
+  EXPECT_EQ(kIcePwd2, transport_remote_desc->ice_pwd);
+  EXPECT_EQ(*remote_fingerprint, *transport_remote_desc->identity_fingerprint);
+  // NegotiateTransportDescription was called because the
+  // transport description was an ANSWER. The SSL role should be set.
+  ASSERT_TRUE(quic_channel->GetSslRole(role.get()));
+  // SSL role should be client because the remote description is an ANSWER.
+  EXPECT_EQ(*role, rtc::SSL_CLIENT);
+}