Create a QUIC wrapper around scoped_refptr.

net/quic/core/quic_headers_stream.cc

 // Copyright 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 "net/quic/core/quic_headers_stream.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 52 matching lines @@
 // session layer.  |ForceAckListener| filters the |OnPacketAcked()|
 // notifications generated by the session layer to not count the extra
 // bytes.  Otherwise, code that is using ack listener on streams might
 // consider it an error if more bytes are acked than were written to
 // the stream, it is the case with some internal stats gathering code.
 class ForceHolAckListener : public QuicAckListenerInterface {
  public:
   // |extra_bytes| should be initialized to the size of the HTTP/2
   // DATA frame header inserted when forced HOL blocking is enabled.
   ForceHolAckListener(
-      scoped_refptr<QuicAckListenerInterface> stream_ack_listener,
+      QuicReferenceCountedPointer<QuicAckListenerInterface> stream_ack_listener,
       int extra_bytes)
       : stream_ack_listener_(std::move(stream_ack_listener)),
         extra_bytes_(extra_bytes) {
     DCHECK_GE(extra_bytes, 0);
   }
 
   void OnPacketAcked(int acked_bytes, QuicTime::Delta ack_delay_time) override {
     if (extra_bytes_ > 0) {
       // Don't count the added HTTP/2 DATA frame header bytes
       int delta = std::min(extra_bytes_, acked_bytes);
       extra_bytes_ -= delta;
       acked_bytes -= delta;
     }
     stream_ack_listener_->OnPacketAcked(acked_bytes, ack_delay_time);
   }
 
   void OnPacketRetransmitted(int retransmitted_bytes) override {
     stream_ack_listener_->OnPacketRetransmitted(retransmitted_bytes);
   }
 
- private:
+ protected:
   ~ForceHolAckListener() override {}
 
-  scoped_refptr<QuicAckListenerInterface> stream_ack_listener_;
+ private:
+  QuicReferenceCountedPointer<QuicAckListenerInterface> stream_ack_listener_;
   int extra_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(ForceHolAckListener);
 };
 
 }  // namespace
 
 QuicHeadersStream::HpackDebugVisitor::HpackDebugVisitor() {}
 
 QuicHeadersStream::HpackDebugVisitor::~HpackDebugVisitor() {}
@@ skipping 229 matching lines @@
   DisableConnectionFlowControlForThisStream();
 }
 
 QuicHeadersStream::~QuicHeadersStream() {}
 
 size_t QuicHeadersStream::WriteHeaders(
     QuicStreamId stream_id,
     SpdyHeaderBlock headers,
     bool fin,
     SpdyPriority priority,
-    scoped_refptr<QuicAckListenerInterface> ack_listener) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   SpdyHeadersIR headers_frame(stream_id, std::move(headers));
   headers_frame.set_fin(fin);
   if (session()->perspective() == Perspective::IS_CLIENT) {
     headers_frame.set_has_priority(true);
     headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
   }
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(headers_frame));
   WriteOrBufferData(StringPiece(frame.data(), frame.size()), false,
                     std::move(ack_listener));
   return frame.size();
@@ skipping 16 matching lines @@
 
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(push_promise));
   WriteOrBufferData(StringPiece(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
 void QuicHeadersStream::WriteDataFrame(
     QuicStreamId id,
     StringPiece data,
     bool fin,
-    scoped_refptr<QuicAckListenerInterface> ack_notifier_delegate) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface>
+        ack_notifier_delegate) {
   SpdyDataIR spdy_data(id, data);
   spdy_data.set_fin(fin);
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(spdy_data));
-  scoped_refptr<ForceHolAckListener> ack_listener;
+  QuicReferenceCountedPointer<ForceHolAckListener> ack_listener;
   if (ack_notifier_delegate != nullptr) {
     ack_listener = new ForceHolAckListener(std::move(ack_notifier_delegate),
                                            frame.size() - data.length());
   }
   // Use buffered writes so that coherence of framing is preserved
   // between streams.
   WriteOrBufferData(StringPiece(frame.data(), frame.size()), false,
                     std::move(ack_listener));
 }
 
 QuicConsumedData QuicHeadersStream::WritevStreamData(
     QuicStreamId id,
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
-    scoped_refptr<QuicAckListenerInterface> ack_notifier_delegate) {
+    QuicReferenceCountedPointer<QuicAckListenerInterface>
+        ack_notifier_delegate) {
   const size_t max_len =
       kSpdyInitialFrameSizeLimit - SpdyConstants::kDataFrameMinimumSize;
 
   QuicConsumedData result(0, false);
   size_t total_length = iov.total_length;
 
   if (total_length == 0 && fin) {
     WriteDataFrame(id, StringPiece(), true, std::move(ack_notifier_delegate));
     result.fin_consumed = true;
     return result;
@@ skipping 211 matching lines @@
     return true;
   }
   frame_len_ -= len;
   // Ignore fin_ while there is more data coming, if frame_len_ > 0.
   spdy_session_->OnStreamFrameData(stream_id, data, len,
                                    frame_len_ > 0 ? false : fin_);
   return true;
 }
 
 }  // namespace net