Refactoring output of ProofSource::GetProof (no functional changes).

net/tools/quic/quic_dispatcher_test.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/tools/quic/quic_dispatcher.h"
 
 #include <memory>
 #include <ostream>
 #include <string>
 
@@ skipping 1046 matching lines @@
 }
 
 // A dispatcher whose stateless rejector will always ACCEPTs CHLO.
 class BufferedPacketStoreTest
     : public QuicDispatcherTest,
       public ::testing::WithParamInterface<BufferedPacketStoreTestParams> {
  public:
   BufferedPacketStoreTest()
       : QuicDispatcherTest(),
         client_addr_(Loopback4(), 1234),
-        proof_(new QuicCryptoProof) {
+        signed_config_(new QuicSignedServerConfig) {
     FLAGS_quic_use_cheap_stateless_rejects =
         GetParam().support_cheap_stateless_reject;
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().enable_stateless_rejects_via_flag;
   }
 
   void SetUp() override {
     QuicDispatcherTest::SetUp();
     clock_ = QuicDispatcherPeer::GetHelper(dispatcher_.get())->GetClock();
 
     QuicVersion version = AllSupportedVersions().front();
     CryptoHandshakeMessage chlo = CryptoTestUtils::GenerateDefaultInchoateCHLO(
         clock_, version, &crypto_config_);
     chlo.SetVector(net::kCOPT, net::QuicTagVector{net::kSREJ});
     // Pass an inchoate CHLO.
     CryptoTestUtils::GenerateFullCHLO(
         chlo, &crypto_config_, server_ip_, client_addr_, version, clock_,
-        proof_, QuicDispatcherPeer::GetCache(dispatcher_.get()), &full_chlo_);
+        signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
+        &full_chlo_);
   }
 
   string SerializeFullCHLO() {
     return full_chlo_.GetSerialized().AsStringPiece().as_string();
   }
 
  protected:
   IPAddress server_ip_;
   IPEndPoint client_addr_;
-  scoped_refptr<QuicCryptoProof> proof_;
+  scoped_refptr<QuicSignedServerConfig> signed_config_;
   const QuicClock* clock_;
   CryptoHandshakeMessage full_chlo_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     BufferedPacketStoreTests,
     BufferedPacketStoreTest,
     ::testing::ValuesIn(GetBufferedPacketStoreTestParams()));
 
 TEST_P(BufferedPacketStoreTest, ProcessNonChloPacketsUptoLimitAndProcessChlo) {
@@ skipping 399 matching lines @@
 
 // Test which exercises the async GetProof codepaths, especially in the context
 // of stateless rejection.
 class AsyncGetProofTest : public QuicDispatcherTest {
  public:
   AsyncGetProofTest()
       : QuicDispatcherTest(
             std::unique_ptr<FakeProofSource>(new FakeProofSource())),
         client_addr_(net::test::Loopback4(), 1234),
         crypto_config_peer_(&crypto_config_),
-        proof_(new QuicCryptoProof) {
+        signed_config_(new QuicSignedServerConfig) {
     FLAGS_enable_async_get_proof = true;
     FLAGS_enable_quic_stateless_reject_support = true;
     FLAGS_quic_use_cheap_stateless_rejects = true;
     FLAGS_quic_create_session_after_insertion = true;
   }
 
   void SetUp() override {
     QuicDispatcherTest::SetUp();
 
     clock_ = QuicDispatcherPeer::GetHelper(dispatcher_.get())->GetClock();
     QuicVersion version = AllSupportedVersions().front();
     chlo_ = CryptoTestUtils::GenerateDefaultInchoateCHLO(clock_, version,
                                                          &crypto_config_);
     chlo_.SetVector(net::kCOPT, net::QuicTagVector{net::kSREJ});
     // Pass an inchoate CHLO.
     CryptoTestUtils::GenerateFullCHLO(
         chlo_, &crypto_config_, server_ip_, client_addr_, version, clock_,
-        proof_, QuicDispatcherPeer::GetCache(dispatcher_.get()), &full_chlo_);
+        signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
+        &full_chlo_);
 
     GetFakeProofSource()->Activate();
   }
 
   FakeProofSource* GetFakeProofSource() const {
     return static_cast<FakeProofSource*>(crypto_config_peer_.GetProofSource());
   }
 
   string SerializeFullCHLO() {
     return full_chlo_.GetSerialized().AsStringPiece().as_string();
@@ skipping 29 matching lines @@
     CHECK(ok);
     return session;
   }
 
  protected:
   const IPEndPoint client_addr_;
 
  private:
   QuicCryptoServerConfigPeer crypto_config_peer_;
   IPAddress server_ip_;
-  scoped_refptr<QuicCryptoProof> proof_;
+  scoped_refptr<QuicSignedServerConfig> signed_config_;
   const QuicClock* clock_;
   CryptoHandshakeMessage chlo_;
   CryptoHandshakeMessage full_chlo_;
 
   struct SessionInfo {
     TestQuicSpdyServerSession* session;
     std::unique_ptr<MockQuicCryptoServerStream> crypto_stream;
   };
   std::map<QuicConnectionId, SessionInfo> sessions_;
 };
@@ skipping 390 matching lines @@
   check.Call(2);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
   EXPECT_FALSE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net