Update QuicTransportChannel to latest version of libquic

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.
  */
 
@@ skipping 28 matching lines @@
 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";
 
 // QUIC packet parameters.
-static const net::IPAddressNumber kIpAddress(net::kIPv4AddressSize, 0);
+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;
 }
 
 // Maps SSL role to ICE connection role. The peer with a client role is assumed
 // to be the one who initiates the connection.
 static ConnectionRole SslRoleToConnectionRole(rtc::SSLRole ssl_role) {
@@ skipping 77 matching lines @@
   }
 
   // Creates fingerprint from certificate.
   rtc::SSLFingerprint* CreateFingerprint(rtc::RTCCertificate* cert) {
     std::string digest_algorithm;
     bool get_digest_algorithm =
         cert->ssl_certificate().GetSignatureDigestAlgorithm(&digest_algorithm);
     if (!get_digest_algorithm || digest_algorithm.empty()) {
       return nullptr;
     }
-    scoped_ptr<rtc::SSLFingerprint> fingerprint(
+    rtc::scoped_ptr<rtc::SSLFingerprint> fingerprint(
         rtc::SSLFingerprint::Create(digest_algorithm, cert->identity()));
     if (digest_algorithm != rtc::DIGEST_SHA_256) {
       return nullptr;
     }
     return fingerprint.release();
   }
 
   // Sends SRTP packet to the other peer via |quic_channel_|.
   int SendSrtpPacket() {
     char packet[kPacketSize];
@@ skipping 244 matching lines @@
 TEST_F(QuicTransportChannelTest, QuicWritePacket) {
   peer1_.ice_channel()->Connect();
   peer2_.ice_channel()->Connect();
   peer1_.ice_channel()->SetDestination(peer2_.ice_channel());
   std::string packet = "FAKEQUICPACKET";
 
   // QUIC should be write blocked when the ICE channel is not writable.
   peer1_.ice_channel()->SetWritable(false);
   EXPECT_TRUE(peer1_.quic_channel()->IsWriteBlocked());
   net::WriteResult write_blocked_result = peer1_.quic_channel()->WritePacket(
-      packet.data(), packet.size(), kIpAddress, kIpEndpoint);
+      packet.data(), packet.size(), kIpAddress, kIpEndpoint, nullptr);
   EXPECT_EQ(net::WRITE_STATUS_BLOCKED, write_blocked_result.status);
   EXPECT_EQ(EWOULDBLOCK, write_blocked_result.error_code);
 
   // QUIC should ignore errors when the ICE channel is writable.
   peer1_.ice_channel()->SetWritable(true);
   EXPECT_FALSE(peer1_.quic_channel()->IsWriteBlocked());
   peer1_.SetWriteError(EWOULDBLOCK);
   net::WriteResult ignore_error_result = peer1_.quic_channel()->WritePacket(
-      packet.data(), packet.size(), kIpAddress, kIpEndpoint);
+      packet.data(), packet.size(), kIpAddress, kIpEndpoint, nullptr);
   EXPECT_EQ(net::WRITE_STATUS_OK, ignore_error_result.status);
   EXPECT_EQ(0, ignore_error_result.bytes_written);
 
   peer1_.SetWriteError(kNoWriteError);
   net::WriteResult no_error_result = peer1_.quic_channel()->WritePacket(
-      packet.data(), packet.size(), kIpAddress, kIpEndpoint);
+      packet.data(), packet.size(), kIpAddress, kIpEndpoint, nullptr);
   EXPECT_EQ(net::WRITE_STATUS_OK, no_error_result.status);
   EXPECT_EQ(static_cast<int>(packet.size()), no_error_result.bytes_written);
 }
 
 // Test that SSL roles can be reversed before QUIC handshake.
 TEST_F(QuicTransportChannelTest, QuicRoleReversalBeforeQuic) {
   EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
   EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_CLIENT));
   EXPECT_TRUE(peer1_.quic_channel()->SetSslRole(rtc::SSL_SERVER));
 }
@@ skipping 41 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());
 }