Create a QUIC wrapper around scoped_refptr.

net/quic/core/quic_stream.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/core/quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_flow_controller.h"
@@ skipping 25 matching lines @@
     return session->config()->ReceivedInitialStreamFlowControlWindowBytes();
   }
 
   return kMinimumFlowControlSendWindow;
 }
 
 }  // namespace
 
 QuicStream::PendingData::PendingData(
     string data_in,
-    scoped_refptr<QuicAckListenerInterface> ack_listener_in)
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener_in)
     : data(std::move(data_in)),
       offset(0),
       ack_listener(std::move(ack_listener_in)) {}
 
 QuicStream::PendingData::~PendingData() {}
 
 QuicStream::QuicStream(QuicStreamId id, QuicSession* session)
     : queued_data_bytes_(0),
       sequencer_(this, session->connection()->clock()),
       id_(id),
@@ skipping 118 matching lines @@
 
 void QuicStream::CloseConnectionWithDetails(QuicErrorCode error,
                                             const string& details) {
   session()->connection()->CloseConnection(
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
 void QuicStream::WriteOrBufferData(
     StringPiece data,
     bool fin,
-    scoped_refptr<QuicAckListenerInterface> ack_listener) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (data.empty() && !fin) {
     QUIC_BUG << "data.empty() && !fin";
     return;
   }
 
   if (fin_buffered_) {
     QUIC_BUG << "Fin already buffered";
     return;
   }
   if (write_side_closed_) {
@@ skipping 16 matching lines @@
     StringPiece remainder(data.substr(consumed_data.bytes_consumed));
     queued_data_bytes_ += remainder.size();
     queued_data_.emplace_back(remainder.as_string(), ack_listener);
   }
 }
 
 void QuicStream::OnCanWrite() {
   bool fin = false;
   while (!queued_data_.empty()) {
     PendingData* pending_data = &queued_data_.front();
-    scoped_refptr<QuicAckListenerInterface> ack_listener =
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener =
         pending_data->ack_listener;
     if (queued_data_.size() == 1 && fin_buffered_) {
       fin = true;
     }
     if (pending_data->offset > 0 &&
         pending_data->offset >= pending_data->data.size()) {
       // This should be impossible because offset tracks the amount of
       // pending_data written thus far.
       QUIC_BUG << "Pending offset is beyond available data. offset: "
                << pending_data->offset << " vs: " << pending_data->data.size();
@@ skipping 30 matching lines @@
   if (connection_flow_controller_->IsBlocked() &&
       !flow_controller_.IsBlocked()) {
     session_->MarkConnectionLevelWriteBlocked(id());
   }
 }
 
 QuicConsumedData QuicStream::WritevData(
     const struct iovec* iov,
     int iov_count,
     bool fin,
-    scoped_refptr<QuicAckListenerInterface> ack_listener) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (write_side_closed_) {
     DLOG(ERROR) << ENDPOINT << "Attempt to write when the write side is closed";
     return QuicConsumedData(0, false);
   }
 
   // How much data was provided.
   size_t write_length = 0;
   if (iov != nullptr) {
     for (int i = 0; i < iov_count; ++i) {
       write_length += iov[i].iov_len;
@@ skipping 60 matching lines @@
   } else {
     session_->MarkConnectionLevelWriteBlocked(id());
   }
   return consumed_data;
 }
 
 QuicConsumedData QuicStream::WritevDataInner(
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
-    scoped_refptr<QuicAckListenerInterface> ack_notifier_delegate) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface>
+        ack_notifier_delegate) {
   return session()->WritevData(this, id(), iov, offset, fin,
                                std::move(ack_notifier_delegate));
 }
 
 void QuicStream::CloseReadSide() {
   if (read_side_closed_) {
     return;
   }
   DVLOG(1) << ENDPOINT << "Done reading from stream " << id();
 
@@ skipping 108 matching lines @@
   }
 }
 
 void QuicStream::UpdateSendWindowOffset(QuicStreamOffset new_window) {
   if (flow_controller_.UpdateSendWindowOffset(new_window)) {
     OnCanWrite();
   }
 }
 
 }  // namespace net