Landing Recent QUIC changes until Sat Oct 29 14:59:35.

net/quic/chromium/crypto/proof_test_chromium.cc

 // Copyright (c) 2013 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 <memory>
 
 #include "base/files/file_path.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 132 matching lines @@
   const string first_chlo_hash = "first chlo hash bytes";
   const string second_chlo_hash = "first chlo hash bytes";
   const QuicVersion quic_version = GetParam();
 
   scoped_refptr<ProofSource::Chain> chain;
   scoped_refptr<ProofSource::Chain> first_chain;
   string error_details, signature, first_signature, first_cert_sct, cert_sct;
   IPAddress server_ip;
 
   ASSERT_TRUE(source->GetProof(server_ip, hostname, server_config, quic_version,
-                               first_chlo_hash, &first_chain, &first_signature,
-                               &first_cert_sct));
+                               first_chlo_hash, QuicTagVector(), &first_chain,
+                               &first_signature, &first_cert_sct));
   ASSERT_TRUE(source->GetProof(server_ip, hostname, server_config, quic_version,
-                               second_chlo_hash, &chain, &signature,
-                               &cert_sct));
+                               second_chlo_hash, QuicTagVector(), &chain,
+                               &signature, &cert_sct));
 
   // Check that the proof source is caching correctly:
   ASSERT_EQ(first_chain->certs, chain->certs);
   ASSERT_NE(signature, first_signature);
   ASSERT_EQ(first_cert_sct, cert_sct);
 
   RunVerification(verifier.get(), hostname, port, server_config, quic_version,
                   first_chlo_hash, chain->certs, signature, true);
 
   RunVerification(verifier.get(), "foo.com", port, server_config, quic_version,
@@ skipping 24 matching lines @@
   const string first_chlo_hash = "first chlo hash bytes";
   const string second_chlo_hash = "first chlo hash bytes";
   const QuicVersion quic_version = GetParam();
   IPAddress server_ip;
 
   // Call synchronous version
   scoped_refptr<ProofSource::Chain> expected_chain;
   string expected_signature;
   string expected_leaf_cert_sct;
   ASSERT_TRUE(source->GetProof(server_ip, hostname, server_config, quic_version,
-                               first_chlo_hash, &expected_chain,
-                               &expected_signature, &expected_leaf_cert_sct));
+                               first_chlo_hash, QuicTagVector(),
+                               &expected_chain, &expected_signature,
+                               &expected_leaf_cert_sct));
 
   // Call asynchronous version and compare results
   bool called = false;
   bool ok;
   scoped_refptr<ProofSource::Chain> chain;
   string signature;
   string leaf_cert_sct;
   std::unique_ptr<ProofSource::Callback> cb(
       new TestCallback(&called, &ok, &chain, &signature, &leaf_cert_sct));
   source->GetProof(server_ip, hostname, server_config, quic_version,
-                   first_chlo_hash, std::move(cb));
+                   first_chlo_hash, QuicTagVector(), std::move(cb));
   // TODO(gredner): whan GetProof really invokes the callback asynchronously,
   // figure out what to do here.
   ASSERT_TRUE(called);
   ASSERT_TRUE(ok);
   EXPECT_THAT(chain->certs, ::testing::ContainerEq(expected_chain->certs));
   EXPECT_EQ(leaf_cert_sct, expected_leaf_cert_sct);
 }
 
 TEST_P(ProofTest, UseAfterFree) {
   std::unique_ptr<ProofSource> source(CryptoTestUtils::ProofSourceForTesting());
 
   const string server_config = "server config bytes";
   const string hostname = "test.example.com";
   const string chlo_hash = "proof nonce bytes";
   scoped_refptr<ProofSource::Chain> chain;
   string error_details, signature, cert_sct;
   IPAddress server_ip;
 
   ASSERT_TRUE(source->GetProof(server_ip, hostname, server_config, GetParam(),
-                               chlo_hash, &chain, &signature, &cert_sct));
+                               chlo_hash, QuicTagVector(), &chain, &signature,
+                               &cert_sct));
 
   // Make sure we can safely access results after deleting where they came from.
   EXPECT_FALSE(chain->HasOneRef());
   source = nullptr;
   EXPECT_TRUE(chain->HasOneRef());
 
   EXPECT_FALSE(chain->certs.empty());
   for (const string& cert : chain->certs) {
     EXPECT_FALSE(cert.empty());
   }
 }
 
 }  // namespace test
 }  // namespace net