Add QuicDataChannel and QuicDataTransport classes

webrtc/p2p/quic/quicsession_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 18 matching lines @@
 #include "webrtc/p2p/quic/reliablequicstream.h"
 
 using net::IPAddress;
 using net::IPEndPoint;
 using net::PerPacketOptions;
 using net::Perspective;
 using net::ProofVerifyContext;
 using net::ProofVerifyDetails;
 using net::QuicByteCount;
 using net::QuicClock;
+using net::QuicCompressedCertsCache;
 using net::QuicConfig;
 using net::QuicConnection;
 using net::QuicCryptoClientConfig;
 using net::QuicCryptoServerConfig;
 using net::QuicCryptoClientStream;
 using net::QuicCryptoServerStream;
 using net::QuicCryptoStream;
 using net::QuicErrorCode;
 using net::QuicPacketWriter;
 using net::QuicRandom;
@@ skipping 55 matching lines @@
 
 // Used by QuicCryptoClientConfig to verify server credentials, returning a
 // canned response of QUIC_SUCCESS if |success| is true.
 class FakeProofVerifier : public net::ProofVerifier {
  public:
   explicit FakeProofVerifier(bool success) : success_(success) {}
 
   // ProofVerifier override
   net::QuicAsyncStatus VerifyProof(
       const std::string& hostname,
+      const uint16_t port,
       const std::string& server_config,
+      net::QuicVersion quic_version,
+      base::StringPiece chlo_hash,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
-      const net::ProofVerifyContext* verify_context,
+      const ProofVerifyContext* context,
       std::string* error_details,
-      scoped_ptr<net::ProofVerifyDetails>* verify_details,
+      std::unique_ptr<ProofVerifyDetails>* details,
       net::ProofVerifierCallback* callback) override {
     return success_ ? net::QUIC_SUCCESS : net::QUIC_FAILURE;
   }
 
  private:
   // Whether or not proof verification succeeds.
   bool success_;
 };
 
 // Writes QUIC packets to a fake transport channel that simulates a network.
@@ skipping 92 matching lines @@
   // Stores data received by peer once it is sent from the other peer.
   std::string last_received_data_;
   // Handles incoming streams from sender.
   ReliableQuicStream* last_incoming_stream_ = nullptr;
 };
 
 // Simulates data transfer between two peers using QUIC.
 class QuicSessionTest : public ::testing::Test,
                         public QuicCryptoClientStream::ProofHandler {
  public:
-  QuicSessionTest() : quic_helper_(rtc::Thread::Current()) {}
+  QuicSessionTest()
+      : quic_helper_(rtc::Thread::Current()),
+        quic_compressed_certs_cache_(
+            QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {}
 
   // Instantiates |client_peer_| and |server_peer_|.
   void CreateClientAndServerSessions();
 
   rtc::scoped_ptr<QuicSessionForTest> CreateSession(
       rtc::scoped_ptr<FakeTransportChannel> channel,
       Perspective perspective);
 
   QuicCryptoClientStream* CreateCryptoClientStream(QuicSessionForTest* session,
                                                    bool handshake_success);
@@ skipping 16 matching lines @@
   // QuicCryptoClientStream::ProofHelper overrides.
   void OnProofValid(
       const QuicCryptoClientConfig::CachedState& cached) override {}
   void OnProofVerifyDetailsAvailable(
       const ProofVerifyDetails& verify_details) override {}
 
  protected:
   QuicConnectionHelper quic_helper_;
   QuicConfig config_;
   QuicClock clock_;
+  QuicCompressedCertsCache quic_compressed_certs_cache_;
 
   rtc::scoped_ptr<QuicSessionForTest> client_peer_;
   rtc::scoped_ptr<QuicSessionForTest> server_peer_;
 };
 
 // Initializes "client peer" who begins crypto handshake and "server peer" who
 // establishes encryption with client.
 void QuicSessionTest::CreateClientAndServerSessions() {
   rtc::scoped_ptr<FakeTransportChannel> channel1(
       new FakeTransportChannel("channel1", 0));
@@ skipping 36 matching lines @@
     QuicSessionForTest* session,
     bool handshake_success) {
   QuicCryptoServerConfig* server_config =
       new QuicCryptoServerConfig("TESTING", QuicRandom::GetInstance(),
                                  new FakeProofSource(handshake_success));
   // Provide server with serialized config string to prove ownership.
   QuicCryptoServerConfig::ConfigOptions options;
   QuicServerConfigProtobuf* primary_config = server_config->GenerateConfig(
       QuicRandom::GetInstance(), &clock_, options);
   server_config->AddConfig(primary_config, clock_.WallNow());
-  return new QuicCryptoServerStream(server_config, session);
+  bool use_stateless_rejects_if_peer_supported = false;
+  return new QuicCryptoServerStream(
+      server_config, &quic_compressed_certs_cache_,
+      use_stateless_rejects_if_peer_supported, session);
 }
 
 rtc::scoped_ptr<QuicConnection> QuicSessionTest::CreateConnection(
     FakeTransportChannel* channel,
     Perspective perspective) {
   FakeQuicPacketWriter* writer = new FakeQuicPacketWriter(channel);
 
   IPAddress ip(0, 0, 0, 0);
   bool owns_writer = true;
 
@@ skipping 13 matching lines @@
 void QuicSessionTest::TestStreamConnection(QuicSessionForTest* from_session,
                                            QuicSessionForTest* to_session) {
   // Wait for crypto handshake to finish then check if encryption established.
   ASSERT_TRUE_WAIT(from_session->IsCryptoHandshakeConfirmed() &&
                        to_session->IsCryptoHandshakeConfirmed(),
                    kTimeoutMs);
 
   ASSERT_TRUE(from_session->IsEncryptionEstablished());
   ASSERT_TRUE(to_session->IsEncryptionEstablished());
 
-  string from_key;
-  string to_key;
+  std::string from_key;
+  std::string to_key;
 
   bool from_success = from_session->ExportKeyingMaterial(
       kExporterLabel, kExporterContext, kExporterContextLen, &from_key);
   ASSERT_TRUE(from_success);
   bool to_success = to_session->ExportKeyingMaterial(
       kExporterLabel, kExporterContext, kExporterContextLen, &to_key);
   ASSERT_TRUE(to_success);
 
   EXPECT_EQ(from_key.size(), kExporterContextLen);
   EXPECT_EQ(from_key, to_key);
@@ skipping 85 matching lines @@
   StartHandshake(true, true);
   ASSERT_TRUE_WAIT(client_peer_->IsCryptoHandshakeConfirmed() &&
                        server_peer_->IsCryptoHandshakeConfirmed(),
                    kTimeoutMs);
   ReliableQuicStream* stream = client_peer_->CreateOutgoingDynamicStream(5);
   ASSERT_NE(nullptr, stream);
   EXPECT_FALSE(client_peer_->IsClosedStream(stream->id()));
   stream->Close();
   EXPECT_TRUE(client_peer_->IsClosedStream(stream->id()));
 }