Create a QUIC wrapper around scoped_refptr.

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 <memory>
 
 #include "base/strings/string_util.h"
 #include "crypto/openssl_util.h"
@@ skipping 256 matching lines @@
     : channel_id_enabled(false), channel_id_source_async(false) {}
 
 CryptoTestUtils::FakeClientOptions::~FakeClientOptions() {}
 
 namespace {
 // This class is used by GenerateFullCHLO() to extract SCID and STK from
 // REJ/SREJ and to construct a full CHLO with these fields and given inchoate
 // CHLO.
 class FullChloGenerator {
  public:
-  FullChloGenerator(QuicCryptoServerConfig* crypto_config,
-                    QuicSocketAddress server_addr,
-                    QuicSocketAddress client_addr,
-                    const QuicClock* clock,
-                    scoped_refptr<QuicSignedServerConfig> signed_config,
-                    QuicCompressedCertsCache* compressed_certs_cache,
-                    CryptoHandshakeMessage* out)
+  FullChloGenerator(
+      QuicCryptoServerConfig* crypto_config,
+      QuicSocketAddress server_addr,
+      QuicSocketAddress client_addr,
+      const QuicClock* clock,
+      QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config,
+      QuicCompressedCertsCache* compressed_certs_cache,
+      CryptoHandshakeMessage* out)
       : crypto_config_(crypto_config),
         server_addr_(server_addr),
         client_addr_(client_addr),
         clock_(clock),
         signed_config_(signed_config),
         compressed_certs_cache_(compressed_certs_cache),
         out_(out),
         params_(new QuicCryptoNegotiatedParameters) {}
 
   class ValidateClientHelloCallback : public ValidateClientHelloResultCallback {
    public:
     explicit ValidateClientHelloCallback(FullChloGenerator* generator)
         : generator_(generator) {}
-    void Run(scoped_refptr<ValidateClientHelloResultCallback::Result> result,
+    void Run(QuicReferenceCountedPointer<
+                 ValidateClientHelloResultCallback::Result> result,
              std::unique_ptr<ProofSource::Details> /* details */) override {
       generator_->ValidateClientHelloDone(std::move(result));
     }
 
    private:
     FullChloGenerator* generator_;
   };
 
   std::unique_ptr<ValidateClientHelloCallback>
   GetValidateClientHelloCallback() {
     return std::unique_ptr<ValidateClientHelloCallback>(
         new ValidateClientHelloCallback(this));
   }
 
  private:
   void ValidateClientHelloDone(
-      scoped_refptr<ValidateClientHelloResultCallback::Result> result) {
+      QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+          result) {
     result_ = result;
     crypto_config_->ProcessClientHello(
         result_, /*reject_only=*/false, /*connection_id=*/1, server_addr_,
         client_addr_, AllSupportedVersions().front(), AllSupportedVersions(),
         /*use_stateless_rejects=*/true, /*server_designated_connection_id=*/0,
         clock_, QuicRandom::GetInstance(), compressed_certs_cache_, params_,
         signed_config_, /*total_framing_overhead=*/50, kDefaultMaxPacketSize,
         GetProcessClientHelloCallback());
   }
 
@@ skipping 41 matching lines @@
     out_->SetStringPiece(kSourceAddressTokenTag, srct);
     uint64_t xlct = CryptoTestUtils::LeafCertHashForTesting();
     out_->SetValue(kXLCT, xlct);
   }
 
  protected:
   QuicCryptoServerConfig* crypto_config_;
   QuicSocketAddress server_addr_;
   QuicSocketAddress client_addr_;
   const QuicClock* clock_;
-  scoped_refptr<QuicSignedServerConfig> signed_config_;
+  QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
   QuicCompressedCertsCache* compressed_certs_cache_;
   CryptoHandshakeMessage* out_;
 
-  scoped_refptr<QuicCryptoNegotiatedParameters> params_;
-  scoped_refptr<ValidateClientHelloResultCallback::Result> result_;
+  QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+  QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
+      result_;
 };
 
 }  // namespace
 
 // static
 int CryptoTestUtils::HandshakeWithFakeServer(
     QuicConfig* server_quic_config,
     MockQuicConnectionHelper* helper,
     MockAlarmFactory* alarm_factory,
     PacketSavingConnection* client_conn,
@@ skipping 166 matching lines @@
 string CryptoTestUtils::GetValueForTag(const CryptoHandshakeMessage& message,
                                        QuicTag tag) {
   QuicTagValueMap::const_iterator it = message.tag_value_map().find(tag);
   if (it == message.tag_value_map().end()) {
     return string();
   }
   return it->second;
 }
 
 uint64_t CryptoTestUtils::LeafCertHashForTesting() {
-  scoped_refptr<ProofSource::Chain> chain;
+  QuicReferenceCountedPointer<ProofSource::Chain> chain;
   QuicSocketAddress server_address;
   QuicCryptoProof proof;
   std::unique_ptr<ProofSource> proof_source(
       CryptoTestUtils::ProofSourceForTesting());
   if (!proof_source->GetProof(server_address, "", "",
                               AllSupportedVersions().front(), "",
                               QuicTagVector(), &chain, &proof) ||
       chain->certs.empty()) {
     DCHECK(false) << "Proof generation failed";
     return 0;
@@ skipping 420 matching lines @@
 }
 
 // static
 void CryptoTestUtils::GenerateFullCHLO(
     const CryptoHandshakeMessage& inchoate_chlo,
     QuicCryptoServerConfig* crypto_config,
     QuicSocketAddress server_addr,
     QuicSocketAddress client_addr,
     QuicVersion version,
     const QuicClock* clock,
-    scoped_refptr<QuicSignedServerConfig> proof,
+    QuicReferenceCountedPointer<QuicSignedServerConfig> proof,
     QuicCompressedCertsCache* compressed_certs_cache,
     CryptoHandshakeMessage* out) {
   // Pass a inchoate CHLO.
   FullChloGenerator generator(crypto_config, server_addr, client_addr, clock,
                               proof, compressed_certs_cache, out);
   crypto_config->ValidateClientHello(
       inchoate_chlo, client_addr.host(), server_addr, version, clock, proof,
       generator.GetValidateClientHelloCallback());
 }
 
 }  // namespace test
 }  // namespace net