Landing Recent QUIC changes until Sat Sep 10 00:32:41

net/quic/test_tools/crypto_test_utils.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/test_tools/crypto_test_utils.h"
 
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
@@ skipping 274 matching lines @@
                     QuicCompressedCertsCache* compressed_certs_cache,
                     CryptoHandshakeMessage* out)
       : crypto_config_(crypto_config),
         server_ip_(server_ip),
         client_addr_(client_addr),
         clock_(clock),
         proof_(proof),
         compressed_certs_cache_(compressed_certs_cache),
         out_(out) {}
 
-  void RunImpl(const CryptoHandshakeMessage& client_hello,
-               const ValidateClientHelloResultCallback::Result& result,
-               std::unique_ptr<ProofSource::Details> /* details */) override {
+  void Run(std::unique_ptr<ValidateClientHelloResultCallback::Result> result,
+           std::unique_ptr<ProofSource::Details> /* details */) override {
     QuicCryptoNegotiatedParameters params;
     string error_details;
     DiversificationNonce diversification_nonce;
     CryptoHandshakeMessage rej;
     crypto_config_->ProcessClientHello(
-        result, /*reject_only=*/false, /*connection_id=*/1, server_ip_,
+        *result, /*reject_only=*/false, /*connection_id=*/1, server_ip_,
         client_addr_, AllSupportedVersions().front(), AllSupportedVersions(),
         /*use_stateless_rejects=*/true, /*server_designated_connection_id=*/0,
         clock_, QuicRandom::GetInstance(), compressed_certs_cache_, &params,
         proof_, /*total_framing_overhead=*/50, kDefaultMaxPacketSize, &rej,
         &diversification_nonce, &error_details);
     // Verify output is a REJ or SREJ.
     EXPECT_THAT(rej.tag(),
                 testing::AnyOf(testing::Eq(kSREJ), testing::Eq(kREJ)));
 
     VLOG(1) << "Extract valid STK and SCID from\n" << rej.DebugString();
     StringPiece srct;
     ASSERT_TRUE(rej.GetStringPiece(kSourceAddressTokenTag, &srct));
 
     StringPiece scfg;
     ASSERT_TRUE(rej.GetStringPiece(kSCFG, &scfg));
     std::unique_ptr<CryptoHandshakeMessage> server_config(
         CryptoFramer::ParseMessage(scfg));
 
     StringPiece scid;
     ASSERT_TRUE(server_config->GetStringPiece(kSCID, &scid));
 
-    *out_ = client_hello;
+    *out_ = result->client_hello;
     out_->SetStringPiece(kSCID, scid);
     out_->SetStringPiece(kSourceAddressTokenTag, srct);
     uint64_t xlct = CryptoTestUtils::LeafCertHashForTesting();
     out_->SetValue(kXLCT, xlct);
   }
 
  protected:
   QuicCryptoServerConfig* crypto_config_;
   IPAddress server_ip_;
   IPEndPoint client_addr_;
@@ skipping 624 matching lines @@
     IPAddress server_ip,
     IPEndPoint client_addr,
     QuicVersion version,
     const QuicClock* clock,
     QuicCryptoProof* proof,
     QuicCompressedCertsCache* compressed_certs_cache,
     CryptoHandshakeMessage* out) {
   // Pass a inchoate CHLO.
   crypto_config->ValidateClientHello(
       inchoate_chlo, client_addr.address(), server_ip, version, clock, proof,
-      new FullChloGenerator(crypto_config, server_ip, client_addr, clock, proof,
-                            compressed_certs_cache, out));
+      std::unique_ptr<FullChloGenerator>(
+          new FullChloGenerator(crypto_config, server_ip, client_addr, clock,
+                                proof, compressed_certs_cache, out)));
 }
 
 }  // namespace test
 }  // namespace net