Replace QuicAckListenerInterface* with scoped_refptr<QuicAckListenerInterface>.

net/quic/core/quic_headers_stream_test.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 <ostream>
 #include <string>
 #include <tuple>
 #include <utility>
@@ skipping 246 matching lines @@
 
   QuicConsumedData SaveIovShort(const QuicIOVector& data) {
     const iovec* iov = data.iov;
     int consumed = 1;
     saved_data_.append(static_cast<char*>(iov[0].iov_base), consumed);
     return QuicConsumedData(consumed, false);
   }
 
   QuicConsumedData SaveIovAndNotifyAckListener(
       const QuicIOVector& data,
-      QuicAckListenerInterface* ack_listener) {
+      const scoped_refptr<QuicAckListenerInterface>& ack_listener) {
     QuicConsumedData result = SaveIov(data);
     if (ack_listener) {
       ack_listener->OnPacketAcked(result.bytes_consumed,
                                   QuicTime::Delta::Zero());
     }
     return result;
   }
 
   void SavePayload(const char* data, size_t len) {
     saved_payloads_.append(data, len);
@@ skipping 39 matching lines @@
 
   void WriteAndExpectResponseHeaders(QuicStreamId stream_id, bool fin) {
     WriteHeadersAndCheckData(stream_id, fin, 0, false /*is_request*/);
   }
 
   void WriteHeadersAndCheckData(QuicStreamId stream_id,
                                 bool fin,
                                 SpdyPriority priority,
                                 bool is_request) {
     // Write the headers and capture the outgoing data
-    EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
-                                     false, nullptr))
+    EXPECT_CALL(session_,
+                WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
         .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
     headers_stream_->WriteHeaders(stream_id, headers_.Clone(), fin, priority,
                                   nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
     if (is_request) {
       EXPECT_CALL(visitor_,
                   OnHeaders(stream_id, kHasPriority,
                             Spdy3PriorityToHttp2Weight(priority),
                             /*parent_stream_id=*/0,
@@ skipping 97 matching lines @@
     }
   }
 }
 
 TEST_P(QuicHeadersStreamTest, WritePushPromises) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     if (perspective() == Perspective::IS_SERVER) {
       // Write the headers and capture the outgoing data
-      EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _,
-                                       false, nullptr))
+      EXPECT_CALL(session_,
+                  WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
           .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
       headers_stream_->WritePushPromise(stream_id, promised_stream_id,
                                         headers_.Clone());
 
       // Parse the outgoing data and check that it matches was was written.
       EXPECT_CALL(visitor_,
                   OnPushPromise(stream_id, promised_stream_id, kFrameComplete));
       headers_handler_.reset(new TestHeadersHandler);
       EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))
           .WillOnce(Return(headers_handler_.get()));
@@ skipping 498 matching lines @@
       scoped_refptr<ForceHolAckListener> ack_listener;
       if (use_ack_listener) {
         ack_listener = new ForceHolAckListener();
       }
       EXPECT_CALL(session_,
                   WritevData(headers_stream_, kHeadersStreamId, _, _, false, _))
           .WillRepeatedly(WithArgs<2, 5>(Invoke(
               this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener)));
 
       QuicConsumedData consumed_data = headers_stream_->WritevStreamData(
-          id, MakeIOVector(data, &iov), offset, fin, ack_listener.get());
+          id, MakeIOVector(data, &iov), offset, fin, ack_listener);
 
       EXPECT_EQ(consumed_data.bytes_consumed, data_len);
       EXPECT_EQ(consumed_data.fin_consumed, fin);
       // Now process the written data with the SPDY framer, and verify
       // that the original data is unchanged.
       EXPECT_CALL(visitor_, OnDataFrameHeader(id, _, _))
           .Times(AtLeast(kMinDataFrames));
       EXPECT_CALL(visitor_, OnStreamFrameData(id, _, _))
           .WillRepeatedly(WithArgs<1, 2>(
               Invoke(this, &QuicHeadersStreamTest::SavePayload)));
@@ skipping 68 matching lines @@
   consumed_data = headers_stream_->WritevStreamData(
       id, MakeIOVector(data, &iov), offset, fin, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net