Create a QUIC wrapper around scoped_refptr.

net/quic/core/quic_stream_test.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 <memory>
 
 #include "base/memory/ptr_util.h"
 #include "net/quic/core/quic_connection.h"
@@ skipping 125 matching lines @@
     return write_blocked_list_->HasWriteBlockedCryptoOrHeadersStream() ||
            write_blocked_list_->HasWriteBlockedDataStreams();
   }
 
   QuicConsumedData CloseStreamOnWriteError(
       QuicStream* /*stream*/,
       QuicStreamId id,
       QuicIOVector /*iov*/,
       QuicStreamOffset /*offset*/,
       bool /*fin*/,
-      const scoped_refptr<
+      const QuicReferenceCountedPointer<
           QuicAckListenerInterface>& /*ack_notifier_delegate*/) {
     session_->CloseStream(id);
     return QuicConsumedData(1, false);
   }
 
  protected:
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicConnection* connection_;
   std::unique_ptr<MockQuicSession> session_;
@@ skipping 223 matching lines @@
   stream_->OnWindowUpdateFrame(window_update_2);
   stream_->OnWindowUpdateFrame(window_update_3);
   stream_->OnWindowUpdateFrame(window_update_4);
   EXPECT_EQ(
       window_update_3.byte_offset,
       QuicFlowControllerPeer::SendWindowOffset(stream_->flow_controller()));
 }
 
 // TODO(ianswett): It's not clear this method is still needed now that
 // ProxyAckNotifierDelegate has been removed.
-void SaveAckListener(scoped_refptr<QuicAckListenerInterface>* listener_out,
-                     scoped_refptr<QuicAckListenerInterface> listener) {
+void SaveAckListener(
+    QuicReferenceCountedPointer<QuicAckListenerInterface>* listener_out,
+    QuicReferenceCountedPointer<QuicAckListenerInterface> listener) {
   *listener_out = std::move(listener);
 }
 
 TEST_F(QuicStreamTest, WriteOrBufferDataWithQuicAckNotifier) {
   Initialize(kShouldProcessData);
 
-  scoped_refptr<MockAckListener> delegate(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> delegate(
+      new StrictMock<MockAckListener>);
 
   const int kDataSize = 16 * 1024;
   const string kData(kDataSize, 'a');
 
   const int kFirstWriteSize = 100;
   const int kSecondWriteSize = 50;
   const int kLastWriteSize = kDataSize - kFirstWriteSize - kSecondWriteSize;
 
   // Set a large flow control send window so this doesn't interfere with test.
   stream_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
   session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
 
-  scoped_refptr<QuicAckListenerInterface> ack_listener;
+  QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener;
 
   EXPECT_CALL(*session_, WritevData(_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
           WithArgs<5>(Invoke(CreateFunctor(SaveAckListener, &ack_listener))),
           Return(QuicConsumedData(kFirstWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, delegate);
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_,
               WritevData(stream_, kTestStreamId, _, _, _, ack_listener))
@@ skipping 10 matching lines @@
               WritevData(stream_, kTestStreamId, _, _, _, ack_listener))
       .WillOnce(Return(QuicConsumedData(kLastWriteSize, false)));
   stream_->OnCanWrite();
 }
 
 // Verify delegate behavior when packets are acked before the WritevData call
 // that sends out the last byte.
 TEST_F(QuicStreamTest, WriteOrBufferDataAckNotificationBeforeFlush) {
   Initialize(kShouldProcessData);
 
-  scoped_refptr<MockAckListener> ack_listener(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> ack_listener(
+      new StrictMock<MockAckListener>);
 
   const int kDataSize = 16 * 1024;
   const string kData(kDataSize, 'a');
 
   const int kInitialWriteSize = 100;
 
   // Set a large flow control send window so this doesn't interfere with test.
   stream_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
   session_->flow_controller()->UpdateSendWindowOffset(kDataSize + 1);
 
-  scoped_refptr<QuicAckListenerInterface> proxy_delegate;
+  QuicReferenceCountedPointer<QuicAckListenerInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
           WithArgs<5>(Invoke(CreateFunctor(SaveAckListener, &proxy_delegate))),
           Return(QuicConsumedData(kInitialWriteSize, false))));
   stream_->WriteOrBufferData(kData, false, ack_listener);
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
           WithArgs<5>(Invoke(CreateFunctor(SaveAckListener, &proxy_delegate))),
           Return(QuicConsumedData(kDataSize - kInitialWriteSize, false))));
   stream_->OnCanWrite();
 }
 
 // Verify delegate behavior when WriteOrBufferData does not buffer.
 TEST_F(QuicStreamTest, WriteAndBufferDataWithAckNotiferNoBuffer) {
   Initialize(kShouldProcessData);
 
-  scoped_refptr<MockAckListener> delegate(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> delegate(
+      new StrictMock<MockAckListener>);
 
-  scoped_refptr<QuicAckListenerInterface> proxy_delegate;
+  QuicReferenceCountedPointer<QuicAckListenerInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
           WithArgs<5>(Invoke(CreateFunctor(SaveAckListener, &proxy_delegate))),
           Return(QuicConsumedData(kDataLen, true))));
   stream_->WriteOrBufferData(kData1, true, delegate);
   EXPECT_FALSE(HasWriteBlockedStreams());
 }
 
 // Verify delegate behavior when WriteOrBufferData buffers all the data.
 TEST_F(QuicStreamTest, BufferOnWriteAndBufferDataWithAckNotifer) {
   Initialize(kShouldProcessData);
 
-  scoped_refptr<MockAckListener> delegate(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> delegate(
+      new StrictMock<MockAckListener>);
 
-  scoped_refptr<QuicAckListenerInterface> proxy_delegate;
+  QuicReferenceCountedPointer<QuicAckListenerInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, false)));
   stream_->WriteOrBufferData(kData1, true, delegate);
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
           WithArgs<5>(Invoke(CreateFunctor(SaveAckListener, &proxy_delegate))),
           Return(QuicConsumedData(kDataLen, true))));
   stream_->OnCanWrite();
 }
 
 // Verify delegate behavior when WriteOrBufferData when the FIN is
 // sent out in a different packet.
 TEST_F(QuicStreamTest, WriteAndBufferDataWithAckNotiferOnlyFinRemains) {
   Initialize(kShouldProcessData);
 
-  scoped_refptr<MockAckListener> delegate(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> delegate(
+      new StrictMock<MockAckListener>);
 
-  scoped_refptr<QuicAckListenerInterface> proxy_delegate;
+  QuicReferenceCountedPointer<QuicAckListenerInterface> proxy_delegate;
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
           WithArgs<5>(Invoke(CreateFunctor(SaveAckListener, &proxy_delegate))),
           Return(QuicConsumedData(kDataLen, false))));
   stream_->WriteOrBufferData(kData1, true, delegate);
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   EXPECT_CALL(*session_, WritevData(stream_, kTestStreamId, _, _, _, _))
       .WillOnce(DoAll(
@@ skipping 183 matching lines @@
   // Receive remaining data and FIN for the request.
   QuicStreamFrame frame2(stream_->id(), true, 0, StringPiece("End"));
   stream_->OnStreamFrame(frame2);
   EXPECT_TRUE(stream_->fin_received());
   EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net