Move QuicClient::ClientQuicDataToResend from QuicClient to QuicClientBase.

net/tools/quic/quic_simple_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.
 //
 // A toy client, which connects to a specified port and sends QUIC
 // request to that endpoint.
 
 #ifndef NET_TOOLS_QUIC_QUIC_SIMPLE_CLIENT_H_
 #define NET_TOOLS_QUIC_QUIC_SIMPLE_CLIENT_H_
 
@@ skipping 20 matching lines @@
 class QuicChromiumAlarmFactory;
 class QuicChromiumConnectionHelper;
 class UDPClientSocket;
 
 
 namespace test {
 class QuicClientPeer;
 }  // namespace test
 
 class QuicSimpleClient : public QuicClientBase,
-                         public QuicSpdyStream::Visitor,
                          public QuicChromiumPacketReader::Visitor {
  public:
   class ResponseListener {
    public:
     ResponseListener() {}
     virtual ~ResponseListener() {}
     virtual void OnCompleteResponse(QuicStreamId id,
                                     const HttpResponseHeaders& response_headers,
                                     const std::string& response_body) = 0;
   };
@@ skipping 25 matching lines @@
   // Connect(), but callers are responsible for making sure the crypto handshake
   // completes.
   void StartConnect();
 
   // Disconnects from the QUIC server.
   void Disconnect();
 
   // Sends an HTTP request and does not wait for response before returning.
   void SendRequest(const SpdyHeaderBlock& headers,
                    base::StringPiece body,
-                   bool fin);
+                   bool fin) override;
 
   // Sends an HTTP request and waits for response before returning.
   void SendRequestAndWaitForResponse(const SpdyHeaderBlock& headers,
                                      base::StringPiece body,
                                      bool fin);
 
   // Sends a request simple GET for each URL in |args|, and then waits for
   // each to complete.
   void SendRequestsAndWaitForResponse(
       const base::CommandLine::StringVector& url_list);
 
   // Migrate to a new socket during an active connection.
   bool MigrateSocket(const IPAddress& new_host);
 
   // QuicChromiumPacketReader::Visitor
   void OnReadError(int result, const DatagramClientSocket* socket) override;
   bool OnPacket(const QuicReceivedPacket& packet,
                 IPEndPoint local_address,
                 IPEndPoint peer_address) override;
 
   // QuicSpdyStream::Visitor
   void OnClose(QuicSpdyStream* stream) override;
 
-  // If the crypto handshake has not yet been confirmed, adds the data to the
-  // queue of data to resend if the client receives a stateless reject.
-  // Otherwise, deletes the data.
-  void MaybeAddQuicDataToResend(
-      std::unique_ptr<QuicDataToResend> data_to_resend);
-
   void set_bind_to_address(const IPAddress& address) {
     bind_to_address_ = address;
   }
 
   const IPAddress& bind_to_address() const { return bind_to_address_; }
 
   void set_local_port(int local_port) { local_port_ = local_port; }
 
   const IPEndPoint& server_address() const { return server_address_; }
 
@@ skipping 11 matching lines @@
   const std::string& latest_response_body() const;
 
  protected:
   virtual QuicChromiumAlarmFactory* CreateQuicAlarmFactory();
   virtual QuicChromiumConnectionHelper* CreateQuicConnectionHelper();
   virtual QuicPacketWriter* CreateQuicPacketWriter();
 
  private:
   friend class net::test::QuicClientPeer;
 
-  // Specific QuicClient class for storing data to resend.
-  class ClientQuicDataToResend : public QuicDataToResend {
-   public:
-    // Takes ownership of |headers|.
-    ClientQuicDataToResend(std::unique_ptr<SpdyHeaderBlock> headers,
-                           base::StringPiece body,
-                           bool fin,
-                           QuicSimpleClient* client)
-        : QuicDataToResend(std::move(headers), body, fin), client_(client) {
-      DCHECK(client);
-    }
-
-    ~ClientQuicDataToResend() override {}
-
-    void Resend() override;
-
-   private:
-    QuicSimpleClient* client_;
-
-    DISALLOW_COPY_AND_ASSIGN(ClientQuicDataToResend);
-  };
-
   // Used during initialization: creates the UDP socket FD, sets socket options,
   // and binds the socket to our address.
   bool CreateUDPSocket();
 
   // Read a UDP packet and hand it to the framer.
   bool ReadAndProcessPacket();
 
   void StartPacketReaderIfNotStarted();
 
   //  Used by |helper_| to time alarms.
@@ skipping 30 matching lines @@
 
   // If true, store the latest response code, headers, and body.
   bool store_response_;
   // HTTP response code from most recent response.
   size_t latest_response_code_;
   // HTTP headers from most recent response.
   std::string latest_response_headers_;
   // Body of most recent response.
   std::string latest_response_body_;
 
-  // Keeps track of any data that must be resent upon a subsequent successful
-  // connection, in case the client receives a stateless reject.
-  std::vector<std::unique_ptr<QuicDataToResend>> data_to_resend_on_connect_;
-
   // The log used for the sockets.
   NetLog net_log_;
 
   std::unique_ptr<QuicChromiumPacketReader> packet_reader_;
 
   bool packet_reader_started_;
 
   base::WeakPtrFactory<QuicSimpleClient> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSimpleClient);
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_SIMPLE_CLIENT_H_