Create a QUIC wrapper around scoped_refptr.

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 75 matching lines @@
       comp_callback.WaitForResult();
       ASSERT_EQ(expected_ok, ok);
       break;
   }
 }
 
 class TestCallback : public ProofSource::Callback {
  public:
   explicit TestCallback(bool* called,
                         bool* ok,
-                        scoped_refptr<ProofSource::Chain>* chain,
+                        QuicReferenceCountedPointer<ProofSource::Chain>* chain,
                         QuicCryptoProof* proof)
       : called_(called), ok_(ok), chain_(chain), proof_(proof) {}
 
   void Run(bool ok,
-           const scoped_refptr<ProofSource::Chain>& chain,
+           const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
            const QuicCryptoProof& proof,
            std::unique_ptr<ProofSource::Details> /* details */) override {
     *ok_ = ok;
     *chain_ = chain;
     *proof_ = proof;
     *called_ = true;
   }
 
  private:
   bool* called_;
   bool* ok_;
-  scoped_refptr<ProofSource::Chain>* chain_;
+  QuicReferenceCountedPointer<ProofSource::Chain>* chain_;
   QuicCryptoProof* proof_;
 };
 
 class ProofTest : public ::testing::TestWithParam<QuicVersion> {};
 
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(QuicVersion,
                         ProofTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 // TODO(rtenneti): Enable testing of ProofVerifier. See http://crbug.com/514468.
 TEST_P(ProofTest, DISABLED_Verify) {
   std::unique_ptr<ProofSource> source(CryptoTestUtils::ProofSourceForTesting());
   std::unique_ptr<ProofVerifier> verifier(
       CryptoTestUtils::ProofVerifierForTesting());
 
   const string server_config = "server config bytes";
   const string hostname = "test.example.com";
   const uint16_t port = 8443;
   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;
+  QuicReferenceCountedPointer<ProofSource::Chain> chain;
+  QuicReferenceCountedPointer<ProofSource::Chain> first_chain;
   string error_details;
   QuicCryptoProof proof, first_proof;
   QuicSocketAddress server_addr;
 
   ASSERT_TRUE(source->GetProof(server_addr, hostname, server_config,
                                quic_version, first_chlo_hash, QuicTagVector(),
                                &first_chain, &first_proof));
   ASSERT_TRUE(source->GetProof(server_addr, hostname, server_config,
                                quic_version, second_chlo_hash, QuicTagVector(),
                                &chain, &proof));
@@ skipping 30 matching lines @@
   std::unique_ptr<ProofSource> source(CryptoTestUtils::ProofSourceForTesting());
 
   const string server_config = "server config bytes";
   const string hostname = "test.example.com";
   const string first_chlo_hash = "first chlo hash bytes";
   const string second_chlo_hash = "first chlo hash bytes";
   const QuicVersion quic_version = GetParam();
   QuicSocketAddress server_addr;
 
   // Call synchronous version
-  scoped_refptr<ProofSource::Chain> expected_chain;
+  QuicReferenceCountedPointer<ProofSource::Chain> expected_chain;
   QuicCryptoProof expected_proof;
   ASSERT_TRUE(source->GetProof(server_addr, hostname, server_config,
                                quic_version, first_chlo_hash, QuicTagVector(),
                                &expected_chain, &expected_proof));
 
   // Call asynchronous version and compare results
   bool called = false;
   bool ok;
-  scoped_refptr<ProofSource::Chain> chain;
+  QuicReferenceCountedPointer<ProofSource::Chain> chain;
   QuicCryptoProof proof;
   std::unique_ptr<ProofSource::Callback> cb(
       new TestCallback(&called, &ok, &chain, &proof));
   source->GetProof(server_addr, hostname, server_config, quic_version,
                    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(proof.leaf_cert_scts, expected_proof.leaf_cert_scts);
 }
 
 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;
+  QuicReferenceCountedPointer<ProofSource::Chain> chain;
   string error_details;
   QuicCryptoProof proof;
   QuicSocketAddress server_addr;
 
   ASSERT_TRUE(source->GetProof(server_addr, hostname, server_config, GetParam(),
                                chlo_hash, QuicTagVector(), &chain, &proof));
 
   // 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