Landing Recent QUIC changes until 5:30 PM, Feb 3, 2017 UTC-5

net/quic/core/quic_server_session_base_test.cc

 // Copyright 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 "net/quic/core/quic_server_session_base.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 102 matching lines @@
 
  private:
   QuicHttpResponseCache* response_cache_;  // Owned by QuicServerSessionBaseTest
 };
 
 const size_t kMaxStreamsForTest = 10;
 
 class QuicServerSessionBaseTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicServerSessionBaseTest()
-      : QuicServerSessionBaseTest(CryptoTestUtils::ProofSourceForTesting()) {}
+      : QuicServerSessionBaseTest(crypto_test_utils::ProofSourceForTesting()) {}
 
   explicit QuicServerSessionBaseTest(std::unique_ptr<ProofSource> proof_source)
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance(),
                        std::move(proof_source)),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
     config_.SetMaxStreamsPerConnection(kMaxStreamsForTest, kMaxStreamsForTest);
     config_.SetMaxIncomingDynamicStreamsToSend(kMaxStreamsForTest);
     QuicConfigPeer::SetReceivedMaxIncomingDynamicStreams(&config_,
@@ skipping 461 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(StreamMemberLifetimeTests,
                         StreamMemberLifetimeTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 // Trigger an operation which causes an async invocation of
 // ProofSource::GetProof.  Delay the completion of the operation until after the
 // stream has been destroyed, and verify that there are no memory bugs.
 TEST_P(StreamMemberLifetimeTest, Basic) {
-  FLAGS_quic_reloadable_flag_enable_async_get_proof = true;
   FLAGS_quic_reloadable_flag_enable_quic_stateless_reject_support = true;
   FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects = true;
   FLAGS_quic_reloadable_flag_quic_create_session_after_insertion = true;
 
   const QuicClock* clock = helper_.GetClock();
   QuicVersion version = AllSupportedVersions().front();
-  CryptoHandshakeMessage chlo = CryptoTestUtils::GenerateDefaultInchoateCHLO(
+  CryptoHandshakeMessage chlo = crypto_test_utils::GenerateDefaultInchoateCHLO(
       clock, version, &crypto_config_);
   chlo.SetVector(kCOPT, QuicTagVector{kSREJ});
   std::vector<QuicVersion> packet_version_list = {version};
   std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
       1, true, false, false, kDefaultPathId, 1,
       chlo.GetSerialized().AsStringPiece().as_string(),
       PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
       &packet_version_list));
 
   EXPECT_CALL(stream_helper_, CanAcceptClientHello(_, _, _))
@@ skipping 20 matching lines @@
 
   // Allow the async ProofSource::GetProof call to complete.  Verify (under
   // asan) that this does not result in accesses to any freed memory from the
   // session or its subobjects.
   GetFakeProofSource()->InvokePendingCallback(0);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net