Create a QUIC wrapper around scoped_refptr.

net/quic/core/quic_connection_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_connection.h"
 
 #include <errno.h>
 #include <memory>
 #include <ostream>
 #include <utility>
@@ skipping 498 matching lines @@
           QuicFrame(new QuicStreamFrame()));
     }
     OnSerializedPacket(&serialized_packet);
   }
 
   QuicConsumedData SendStreamDataWithString(
       QuicStreamId id,
       StringPiece data,
       QuicStreamOffset offset,
       bool fin,
-      scoped_refptr<QuicAckListenerInterface> listener) {
+      QuicReferenceCountedPointer<QuicAckListenerInterface> listener) {
     if (id != kCryptoStreamId && this->encryption_level() == ENCRYPTION_NONE) {
       this->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
     }
     struct iovec iov;
     QuicIOVector data_iov(MakeIOVector(data, &iov));
     return QuicConnection::SendStreamData(id, data_iov, offset, fin,
                                           std::move(listener));
   }
 
   QuicConsumedData SendStreamData3() {
@@ skipping 4076 matching lines @@
   EXPECT_EQ(1u, writer_->packets_write_attempts());
   EXPECT_TRUE(writer_->IsWriteBlocked());
   TriggerConnectionClose();
   EXPECT_EQ(1u, writer_->packets_write_attempts());
 }
 
 TEST_P(QuicConnectionTest, AckNotifierTriggerCallback) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a listener which we expect to be called.
-  scoped_refptr<MockAckListener> listener(new MockAckListener);
+  QuicReferenceCountedPointer<MockAckListener> listener(new MockAckListener);
   EXPECT_CALL(*listener, OnPacketAcked(_, _)).Times(1);
 
   // Send some data, which will register the listener to be notified.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, listener);
 
   // Process an ACK from the server which should trigger the callback.
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
   QuicAckFrame frame = InitAckFrame(1);
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierFailToTriggerCallback) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a listener which we don't expect to be called.
-  scoped_refptr<MockAckListener> listener(new MockAckListener);
+  QuicReferenceCountedPointer<MockAckListener> listener(new MockAckListener);
   EXPECT_CALL(*listener, OnPacketAcked(_, _)).Times(0);
 
   // Send some data, which will register the listener to be notified. This will
   // not be ACKed and so the listener should never be called.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, listener);
 
   // Send some other data which we will ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(1, "bar", 0, !kFin, nullptr);
 
   // Now we receive ACK for packets 2 and 3, but importantly missing packet 1
   // which we registered to be notified about.
   QuicAckFrame frame = InitAckFrame(3);
   NackPacket(1, &frame);
   SendAlgorithmInterface::CongestionVector lost_packets;
   lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _))
       .WillOnce(SetArgPointee<4>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterRetransmission) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a listener which we expect to be called.
-  scoped_refptr<MockAckListener> listener(new MockAckListener);
+  QuicReferenceCountedPointer<MockAckListener> listener(new MockAckListener);
   EXPECT_CALL(*listener, OnPacketRetransmitted(3)).Times(1);
   EXPECT_CALL(*listener, OnPacketAcked(3, _)).Times(1);
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, listener);
   connection_.SendStreamDataWithString(3, "baz", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "qux", 0, !kFin, nullptr);
 
   // Now we receive ACK for packets 1, 3, and 4 and lose 2.
@@ skipping 15 matching lines @@
   ProcessAckPacket(&second_ack_frame);
 }
 
 // AckNotifierCallback is triggered by the ack of a packet that timed
 // out and was retransmitted, even though the retransmission has a
 // different packet number.
 TEST_P(QuicConnectionTest, AckNotifierCallbackForAckAfterRTO) {
   connection_.SetMaxTailLossProbes(kDefaultPathId, 0);
 
   // Create a listener which we expect to be called.
-  scoped_refptr<MockAckListener> listener(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> listener(
+      new StrictMock<MockAckListener>);
 
   QuicTime default_retransmission_time =
       clock_.ApproximateNow() + DefaultRetransmissionTime();
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, listener);
   EXPECT_EQ(1u, stop_waiting()->least_unacked);
 
   EXPECT_EQ(1u, writer_->header().packet_number);
   EXPECT_EQ(default_retransmission_time,
             connection_.GetRetransmissionAlarm()->deadline());
   // Simulate the retransmission alarm firing.
@@ skipping 16 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
   QuicAckFrame second_ack_frame = InitAckFrame(2);
   ProcessAckPacket(&second_ack_frame);
 }
 
 // AckNotifierCallback is triggered by the ack of a packet that was
 // previously nacked, even though the retransmission has a different
 // packet number.
 TEST_P(QuicConnectionTest, AckNotifierCallbackForAckOfNackedPacket) {
   // Create a listener which we expect to be called.
-  scoped_refptr<MockAckListener> listener(new StrictMock<MockAckListener>);
+  QuicReferenceCountedPointer<MockAckListener> listener(
+      new StrictMock<MockAckListener>());
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, listener);
   connection_.SendStreamDataWithString(3, "baz", 0, !kFin, nullptr);
   connection_.SendStreamDataWithString(3, "qux", 0, !kFin, nullptr);
 
   // Now we receive ACK for packets 1, 3, and 4 and lose 2.
   QuicAckFrame frame = InitAckFrame(4);
   NackPacket(2, &frame);
@@ skipping 76 matching lines @@
 
   // Ensure that this has caused the ACK alarm to be set.
   QuicAlarm* ack_alarm = QuicConnectionPeer::GetAckAlarm(&connection_);
   EXPECT_TRUE(ack_alarm->IsSet());
 }
 
 TEST_P(QuicConnectionTest, NoDataNoFin) {
   // Make sure that a call to SendStreamWithData, with no data and no FIN, does
   // not result in a QuicAckNotifier being used-after-free (fail under ASAN).
   // Regression test for b/18594622
-  scoped_refptr<MockAckListener> listener(new MockAckListener);
+  QuicReferenceCountedPointer<MockAckListener> listener(new MockAckListener);
   EXPECT_QUIC_BUG(
       connection_.SendStreamDataWithString(3, "", 0, !kFin, listener),
       "Attempt to send empty stream frame");
 }
 
 TEST_P(QuicConnectionTest, DoNotSendGoAwayTwice) {
   EXPECT_FALSE(connection_.goaway_sent());
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
   EXPECT_TRUE(connection_.goaway_sent());
@@ skipping 274 matching lines @@
                             error_details, ConnectionCloseSource::FROM_PEER));
   connection_.set_perspective(Perspective::IS_CLIENT);
   connection_.CloseConnection(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT,
                               error_details,
                               ConnectionCloseBehavior::SILENT_CLOSE);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net