Replace QuicAckListenerInterface* with scoped_refptr<QuicAckListenerInterface>.

net/tools/quic/test_tools/quic_test_client.h

 // 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.
 
 #ifndef NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 #define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 97 matching lines @@
   ~QuicTestClient() override;
 
   // Sets the |user_agent_id| of the |client_|.
   void SetUserAgentID(const std::string& user_agent_id);
 
   // Wraps data in a quic packet and sends it.
   ssize_t SendData(const std::string& data, bool last_data);
   // As above, but |delegate| will be notified when |data| is ACKed.
   ssize_t SendData(const std::string& data,
                    bool last_data,
-                   QuicAckListenerInterface* delegate);
+                   const scoped_refptr<QuicAckListenerInterface>& delegate);
 
   // Clears any outstanding state and sends a simple GET of 'uri' to the
   // server.  Returns 0 if the request failed and no bytes were written.
   ssize_t SendRequest(const std::string& uri);
   // Sends requests for all the urls and waits for the responses.  To process
   // the individual responses as they are returned, the caller should use the
   // set the response_listener on the client().
   void SendRequestsAndWaitForResponses(
       const std::vector<std::string>& url_list);
   // Sends a request containing |headers| and |body| and returns the number of
@@ skipping 79 matching lines @@
   void UseConnectionId(QuicConnectionId connection_id);
 
   // Update internal stream_ pointer and perform accompanying housekeeping.
   void SetStream(QuicSpdyClientStream* stream);
   // Returns nullptr if the maximum number of streams have already been created.
   QuicSpdyClientStream* GetOrCreateStream();
 
   // Calls GetOrCreateStream(), sends the request on the stream, and
   // stores the request in case it needs to be resent.  If |headers| is
   // null, only the body will be sent on the stream.
-  ssize_t GetOrCreateStreamAndSendRequest(const SpdyHeaderBlock* headers,
-                                          base::StringPiece body,
-                                          bool fin,
-                                          QuicAckListenerInterface* delegate);
+  ssize_t GetOrCreateStreamAndSendRequest(
+      const SpdyHeaderBlock* headers,
+      base::StringPiece body,
+      bool fin,
+      const scoped_refptr<QuicAckListenerInterface>& delegate);
 
   QuicRstStreamErrorCode stream_error() { return stream_error_; }
   QuicErrorCode connection_error();
 
   MockableQuicClient* client();
 
   // cert_common_name returns the common name value of the server's certificate,
   // or the empty string if no certificate was presented.
   const std::string& cert_common_name() const;
 
@@ skipping 36 matching lines @@
   void Initialize();
 
   void set_client(MockableQuicClient* client) { client_.reset(client); }
 
  protected:
   QuicTestClient();
 
  private:
   class TestClientDataToResend : public QuicClient::QuicDataToResend {
    public:
-    TestClientDataToResend(std::unique_ptr<SpdyHeaderBlock> headers,
-                           base::StringPiece body,
-                           bool fin,
-                           QuicTestClient* test_client,
-                           QuicAckListenerInterface* delegate)
-        : QuicClient::QuicDataToResend(std::move(headers), body, fin),
-          test_client_(test_client),
-          delegate_(delegate) {}
+    TestClientDataToResend(
+        std::unique_ptr<SpdyHeaderBlock> headers,
+        base::StringPiece body,
+        bool fin,
+        QuicTestClient* test_client,
+        const scoped_refptr<QuicAckListenerInterface>& delegate);
 
-    ~TestClientDataToResend() override {}
+    ~TestClientDataToResend() override;
 
     void Resend() override;
 
    protected:
     QuicTestClient* test_client_;
-    QuicAckListenerInterface* delegate_;
+    scoped_refptr<QuicAckListenerInterface> delegate_;
   };
 
   // Given |uri|, populates the fields in |headers| for a simple GET
   // request. If |uri| is a relative URL, the QuicServerId will be
   // use to specify the authority.
   bool PopulateHeaderBlockFromUrl(const std::string& uri,
                                   SpdyHeaderBlock* headers);
 
   bool HaveActiveStream();
 
@@ skipping 42 matching lines @@
   std::string override_sni_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicTestClient);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_