Create a QUIC wrapper around scoped_refptr.

net/quic/core/crypto/crypto_server_test.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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <vector>
 
@@ skipping 162 matching lines @@
     srct_hex_ = "#" + QuicUtils::HexEncode(srct);
 
     StringPiece scfg;
     ASSERT_TRUE(out_.GetStringPiece(kSCFG, &scfg));
     server_config_.reset(CryptoFramer::ParseMessage(scfg));
 
     StringPiece scid;
     ASSERT_TRUE(server_config_->GetStringPiece(kSCID, &scid));
     scid_hex_ = "#" + QuicUtils::HexEncode(scid);
 
-    signed_config_ =
-        scoped_refptr<QuicSignedServerConfig>(new QuicSignedServerConfig());
+    signed_config_ = QuicReferenceCountedPointer<QuicSignedServerConfig>(
+        new QuicSignedServerConfig());
     DCHECK(signed_config_->chain.get() == nullptr);
   }
 
   // Helper used to accept the result of ValidateClientHello and pass
   // it on to ProcessClientHello.
   class ValidateCallback : public ValidateClientHelloResultCallback {
    public:
     ValidateCallback(CryptoServerTest* test,
                      bool should_succeed,
                      const char* error_substr,
                      bool* called)
         : test_(test),
           should_succeed_(should_succeed),
           error_substr_(error_substr),
           called_(called) {
       *called_ = false;
     }
 
-    void Run(scoped_refptr<Result> result,
+    void Run(QuicReferenceCountedPointer<Result> result,
              std::unique_ptr<ProofSource::Details> /* details */) override {
       ASSERT_FALSE(*called_);
       test_->ProcessValidationResult(std::move(result), should_succeed_,
                                      error_substr_);
       *called_ = true;
     }
 
    private:
     CryptoServerTest* test_;
     const bool should_succeed_;
@@ skipping 42 matching lines @@
     QuicSocketAddress server_address;
     config_.ValidateClientHello(
         message, client_address_.host(), server_address,
         supported_versions_.front(), &clock_, signed_config_,
         std::unique_ptr<ValidateCallback>(
             new ValidateCallback(this, false, error_substr, called)));
   }
 
   class ProcessCallback : public ProcessClientHelloResultCallback {
    public:
-    ProcessCallback(scoped_refptr<ValidateCallback::Result> result,
-                    bool should_succeed,
-                    const char* error_substr,
-                    bool* called,
-                    CryptoHandshakeMessage* out)
+    ProcessCallback(
+        QuicReferenceCountedPointer<ValidateCallback::Result> result,
+        bool should_succeed,
+        const char* error_substr,
+        bool* called,
+        CryptoHandshakeMessage* out)
         : result_(std::move(result)),
           should_succeed_(should_succeed),
           error_substr_(error_substr),
           called_(called),
           out_(out) {
       *called_ = false;
     }
 
     void Run(
         QuicErrorCode error,
@@ skipping 12 matching lines @@
         EXPECT_TRUE(error_details.find(error_substr_) != string::npos)
             << error_substr_ << " not in " << error_details;
       }
       if (message != nullptr) {
         *out_ = *message;
       }
       *called_ = true;
     }
 
    private:
-    const scoped_refptr<ValidateCallback::Result> result_;
+    const QuicReferenceCountedPointer<ValidateCallback::Result> result_;
     const bool should_succeed_;
     const char* const error_substr_;
     bool* called_;
     CryptoHandshakeMessage* out_;
   };
 
-  void ProcessValidationResult(scoped_refptr<ValidateCallback::Result> result,
-                               bool should_succeed,
-                               const char* error_substr) {
+  void ProcessValidationResult(
+      QuicReferenceCountedPointer<ValidateCallback::Result> result,
+      bool should_succeed,
+      const char* error_substr) {
     QuicSocketAddress server_address;
     QuicConnectionId server_designated_connection_id =
         rand_for_id_generation_.RandUint64();
     bool called;
     config_.ProcessClientHello(
         result, /*reject_only=*/false, /*connection_id=*/1, server_address,
         client_address_, supported_versions_.front(), supported_versions_,
         use_stateless_rejects_, server_designated_connection_id, &clock_, rand_,
         &compressed_certs_cache_, params_, signed_config_,
         /*total_framing_overhead=*/50, chlo_packet_size_,
@@ skipping 68 matching lines @@
   QuicRandom* const rand_;
   MockRandom rand_for_id_generation_;
   MockClock clock_;
   QuicSocketAddress client_address_;
   QuicVersionVector supported_versions_;
   QuicVersion client_version_;
   string client_version_string_;
   QuicCryptoServerConfig config_;
   QuicCompressedCertsCache compressed_certs_cache_;
   QuicCryptoServerConfig::ConfigOptions config_options_;
-  scoped_refptr<QuicCryptoNegotiatedParameters> params_;
-  scoped_refptr<QuicSignedServerConfig> signed_config_;
+  QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
+  QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
   CryptoHandshakeMessage out_;
   uint8_t orbit_[kOrbitSize];
   bool use_stateless_rejects_;
   size_t chlo_packet_size_;
 
   // These strings contain hex escaped values from the server suitable for using
   // when constructing client hello messages.
   string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
   std::unique_ptr<CryptoHandshakeMessage> server_config_;
 };
@@ skipping 731 matching lines @@
   // QuicCryptoServerConfig::EvaluateClientHello will leave info.unique as false
   // and cause ProcessClientHello to exit early (and generate a REJ message).
   config_.set_replay_protection(false);
 
   ShouldSucceed(msg);
   EXPECT_EQ(kSHLO, out_.tag());
 }
 
 }  // namespace test
 }  // namespace net