Create a QUIC wrapper around scoped_refptr.

net/quic/test_tools/quic_crypto_server_config_peer.cc

 // Copyright 2016 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/quic_crypto_server_config_peer.h"
 
 #include <cstdarg>
 
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 
 namespace net {
 namespace test {
 
 ProofSource* QuicCryptoServerConfigPeer::GetProofSource() {
   return server_config_->proof_source_.get();
 }
 
-scoped_refptr<QuicCryptoServerConfig::Config>
+QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfigPeer::GetPrimaryConfig() {
   QuicReaderMutexLock locked(&server_config_->configs_lock_);
-  return scoped_refptr<QuicCryptoServerConfig::Config>(
+  return QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>(
       server_config_->primary_config_);
 }
 
-scoped_refptr<QuicCryptoServerConfig::Config>
+QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfigPeer::GetConfig(string config_id) {
   QuicReaderMutexLock locked(&server_config_->configs_lock_);
   if (config_id == "<primary>") {
-    return scoped_refptr<QuicCryptoServerConfig::Config>(
+    return QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>(
         server_config_->primary_config_);
   } else {
     return server_config_->GetConfigWithScid(config_id);
   }
 }
 
 ProofSource* QuicCryptoServerConfigPeer::GetProofSource() const {
   return server_config_->proof_source_.get();
 }
 
@@ skipping 72 matching lines @@
     const bool is_primary = static_cast<bool>(va_arg(ap, int));
     expected.push_back(std::make_pair(server_config_id, is_primary));
   }
 
   va_end(ap);
 
   QuicReaderMutexLock locked(&server_config_->configs_lock_);
 
   ASSERT_EQ(expected.size(), server_config_->configs_.size()) << ConfigsDebug();
 
-  for (const std::pair<const ServerConfigID,
-                       scoped_refptr<QuicCryptoServerConfig::Config>>& i :
+  for (const std::pair<
+           const ServerConfigID,
+           QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>>& i :
        server_config_->configs_) {
     bool found = false;
     for (std::pair<ServerConfigID, bool>& j : expected) {
       if (i.first == j.first && i.second->is_primary == j.second) {
         found = true;
         j.first.clear();
         break;
       }
     }
 
     ASSERT_TRUE(found) << "Failed to find match for " << i.first
                        << " in configs:\n"
                        << ConfigsDebug();
   }
 }
 
 // ConfigsDebug returns a string that contains debugging information about
 // the set of Configs loaded in |server_config_| and their status.
 string QuicCryptoServerConfigPeer::ConfigsDebug() {
   if (server_config_->configs_.empty()) {
     return "No Configs in QuicCryptoServerConfig";
   }
 
   string s;
 
   for (const auto& i : server_config_->configs_) {
-    const scoped_refptr<QuicCryptoServerConfig::Config> config = i.second;
+    const QuicReferenceCountedPointer<QuicCryptoServerConfig::Config> config =
+        i.second;
     if (config->is_primary) {
       s += "(primary) ";
     } else {
       s += "          ";
     }
     s += config->id;
     s += "\n";
   }
 
   return s;
 }
 
 void QuicCryptoServerConfigPeer::SelectNewPrimaryConfig(int seconds) {
   QuicWriterMutexLock locked(&server_config_->configs_lock_);
   server_config_->SelectNewPrimaryConfig(
       QuicWallTime::FromUNIXSeconds(seconds));
 }
 
 string QuicCryptoServerConfigPeer::CompressChain(
     QuicCompressedCertsCache* compressed_certs_cache,
-    const scoped_refptr<ProofSource::Chain>& chain,
+    const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
     const string& client_common_set_hashes,
     const string& client_cached_cert_hashes,
     const CommonCertSets* common_sets) {
   return QuicCryptoServerConfig::CompressChain(
       compressed_certs_cache, chain, client_common_set_hashes,
       client_cached_cert_hashes, common_sets);
 }
 
 uint32_t QuicCryptoServerConfigPeer::source_address_token_future_secs() {
   return server_config_->source_address_token_future_secs_;
 }
 
 uint32_t QuicCryptoServerConfigPeer::source_address_token_lifetime_secs() {
   return server_config_->source_address_token_lifetime_secs_;
 }
 
 }  // namespace test
 }  // namespace net