Create a QUIC wrapper around scoped_refptr.

net/tools/quic/quic_simple_server_session_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/tools/quic/quic_simple_server_session.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 61 matching lines @@
                           QuicStreamId promised_stream_id,
                           SpdyHeaderBlock headers) override {
     return WritePushPromiseMock(original_stream_id, promised_stream_id,
                                 headers);
   }
   MOCK_METHOD3(WritePushPromiseMock,
                size_t(QuicStreamId original_stream_id,
                       QuicStreamId promised_stream_id,
                       const SpdyHeaderBlock& headers));
 
-  size_t WriteHeaders(
-      QuicStreamId stream_id,
-      SpdyHeaderBlock headers,
-      bool fin,
-      SpdyPriority priority,
-      scoped_refptr<QuicAckListenerInterface> ack_listener) override {
+  size_t WriteHeaders(QuicStreamId stream_id,
+                      SpdyHeaderBlock headers,
+                      bool fin,
+                      SpdyPriority priority,
+                      QuicReferenceCountedPointer<QuicAckListenerInterface>
+                          ack_listener) override {
     return WriteHeadersMock(stream_id, headers, fin, priority, ack_listener);
   }
   MOCK_METHOD5(
       WriteHeadersMock,
       size_t(QuicStreamId stream_id,
              const SpdyHeaderBlock& headers,
              bool fin,
              SpdyPriority priority,
-             const scoped_refptr<QuicAckListenerInterface>& ack_listener));
+             const QuicReferenceCountedPointer<QuicAckListenerInterface>&
+                 ack_listener));
 };
 
 class MockQuicCryptoServerStream : public QuicCryptoServerStream {
  public:
   explicit MockQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache,
       QuicServerSessionBase* session,
       QuicCryptoServerStream::Helper* helper)
       : QuicCryptoServerStream(crypto_config,
@@ skipping 21 matching lines @@
       MockAlarmFactory* alarm_factory,
       Perspective perspective,
       const QuicVersionVector& supported_versions)
       : MockQuicConnection(helper,
                            alarm_factory,
                            perspective,
                            supported_versions) {}
 
   MOCK_METHOD5(
       SendStreamData,
-      QuicConsumedData(QuicStreamId id,
-                       QuicIOVector iov,
-                       QuicStreamOffset offset,
-                       bool fin,
-                       scoped_refptr<QuicAckListenerInterface> listern));
+      QuicConsumedData(
+          QuicStreamId id,
+          QuicIOVector iov,
+          QuicStreamOffset offset,
+          bool fin,
+          QuicReferenceCountedPointer<QuicAckListenerInterface> listern));
 };
 
 class QuicSimpleServerSessionPeer {
  public:
   static void SetCryptoStream(QuicSimpleServerSession* s,
                               QuicCryptoServerStream* crypto_stream) {
     s->crypto_stream_.reset(crypto_stream);
     s->static_streams()[kCryptoStreamId] = crypto_stream;
   }
 
@@ skipping 466 matching lines @@
       .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
 
   EXPECT_CALL(*connection_, SendBlocked(stream_to_open));
   QuicRstStreamFrame rst(stream_got_reset, QUIC_STREAM_CANCELLED, 0);
   visitor_->OnRstStream(rst);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net