Create a QUIC wrapper around scoped_refptr.

net/tools/quic/test_tools/quic_test_client.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/test_tools/quic_test_client.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 274 matching lines @@
   }
   while (client()->WaitForEvents()) {
   }
   return;
 }
 
 ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
     const SpdyHeaderBlock* headers,
     StringPiece body,
     bool fin,
-    scoped_refptr<QuicAckListenerInterface> delegate) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface> delegate) {
   if (headers) {
     QuicClientPushPromiseIndex::TryHandle* handle;
     QuicAsyncStatus rv =
         client()->push_promise_index()->Try(*headers, this, &handle);
     if (rv == QUIC_SUCCESS)
       return 1;
     if (rv == QUIC_PENDING) {
       // May need to retry request if asynchronous rendezvous fails.
       std::unique_ptr<SpdyHeaderBlock> new_headers(
           new SpdyHeaderBlock(headers->Clone()));
@@ skipping 64 matching lines @@
   return ret;
 }
 
 ssize_t QuicTestClient::SendData(const string& data, bool last_data) {
   return SendData(data, last_data, nullptr);
 }
 
 ssize_t QuicTestClient::SendData(
     const string& data,
     bool last_data,
-    scoped_refptr<QuicAckListenerInterface> delegate) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface> delegate) {
   return GetOrCreateStreamAndSendRequest(nullptr, StringPiece(data), last_data,
                                          std::move(delegate));
 }
 
 bool QuicTestClient::response_complete() const {
   return response_complete_;
 }
 
 int64_t QuicTestClient::response_body_size() const {
   return response_body_size_;
@@ skipping 279 matching lines @@
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 QuicTestClient::TestClientDataToResend::TestClientDataToResend(
     std::unique_ptr<SpdyHeaderBlock> headers,
     base::StringPiece body,
     bool fin,
     QuicTestClient* test_client,
-    scoped_refptr<QuicAckListenerInterface> delegate)
+    QuicReferenceCountedPointer<QuicAckListenerInterface> delegate)
     : QuicClient::QuicDataToResend(std::move(headers), body, fin),
       test_client_(test_client),
       delegate_(std::move(delegate)) {}
 
 QuicTestClient::TestClientDataToResend::~TestClientDataToResend() {}
 
 void QuicTestClient::TestClientDataToResend::Resend() {
   test_client_->GetOrCreateStreamAndSendRequest(headers_.get(), body_, fin_,
                                                 delegate_);
   headers_.reset();
 }
 
 bool QuicTestClient::PopulateHeaderBlockFromUrl(const string& uri,
                                                 SpdyHeaderBlock* headers) {
   string url;
   if (base::StartsWith(uri, "https://", base::CompareCase::INSENSITIVE_ASCII) ||
       base::StartsWith(uri, "http://", base::CompareCase::INSENSITIVE_ASCII)) {
     url = uri;
   } else if (uri[0] == '/') {
     url = "https://" + client_->server_id().host() + uri;
   } else {
     url = "https://" + uri;
   }
   return SpdyUtils::PopulateHeaderBlockFromUrl(url, headers);
 }
 
 }  // namespace test
 }  // namespace net