Replace QuicAckListenerInterface* with scoped_refptr<QuicAckListenerInterface>.

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 51 matching lines @@
 // HTTP/2 DATA frame headers are inserted on the way down to the
 // 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(QuicAckListenerInterface* stream_ack_listener,
-                      int extra_bytes)
-      : stream_ack_listener_(stream_ack_listener), extra_bytes_(extra_bytes) {
+  ForceHolAckListener(
+      scoped_refptr<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;
     }
@@ skipping 245 matching lines @@
       spdy_framer_(SpdyFramer::ENABLE_COMPRESSION),
       spdy_framer_visitor_(new SpdyFramerVisitor(this)) {
   spdy_framer_.set_visitor(spdy_framer_visitor_.get());
   spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
   // The headers stream is exempt from connection level flow control.
   DisableConnectionFlowControlForThisStream();
 }
 
 QuicHeadersStream::~QuicHeadersStream() {}
 
-size_t QuicHeadersStream::WriteHeaders(QuicStreamId stream_id,
-                                       SpdyHeaderBlock headers,
-                                       bool fin,
-                                       SpdyPriority priority,
-                                       QuicAckListenerInterface* ack_listener) {
+size_t QuicHeadersStream::WriteHeaders(
+    QuicStreamId stream_id,
+    SpdyHeaderBlock headers,
+    bool fin,
+    SpdyPriority priority,
+    const scoped_refptr<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,
                     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,
-    QuicAckListenerInterface* ack_notifier_delegate) {
+    const scoped_refptr<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;
   if (ack_notifier_delegate != nullptr) {
     ack_listener = new ForceHolAckListener(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,
-                    ack_listener.get());
+                    ack_listener);
 }
 
 QuicConsumedData QuicHeadersStream::WritevStreamData(
     QuicStreamId id,
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
-    QuicAckListenerInterface* ack_notifier_delegate) {
+    const scoped_refptr<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, 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