Landing Recent QUIC changes until 10:38 AM, Oct 17, 2016 UTC-4

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>
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_packet_creator.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/tools/balsa/balsa_frame.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_client.h"
-#include "net/tools/quic/test_tools/simple_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPiece;
 
 namespace net {
 
 class ProofVerifier;
 
 class ProofVerifier;
 class QuicPacketWriterWrapper;
@@ skipping 50 matching lines @@
   QuicPacketWriterWrapper* test_writer_;
   CachedNetworkParameters cached_network_paramaters_;
   // The last incoming packet, iff |track_last_incoming_packet_| is true.
   std::unique_ptr<QuicReceivedPacket> last_incoming_packet_;
   // If true, copy each packet from ProcessPacket into |last_incoming_packet_|
   bool track_last_incoming_packet_;
 
   DISALLOW_COPY_AND_ASSIGN(MockableQuicClient);
 };
 
-// A toy QUIC client used for testing, mostly following the SimpleClient APIs.
-class QuicTestClient : public test::SimpleClient,
-                       public QuicSpdyStream::Visitor,
+// A toy QUIC client used for testing.
+class QuicTestClient : public QuicSpdyStream::Visitor,
                        public QuicClientPushPromiseIndex::Delegate {
  public:
   QuicTestClient(IPEndPoint server_address,
                  const std::string& server_hostname,
                  const QuicVersionVector& supported_versions);
   QuicTestClient(IPEndPoint server_address,
                  const std::string& server_hostname,
                  const QuicConfig& config,
                  const QuicVersionVector& supported_versions);
   QuicTestClient(IPEndPoint server_address,
                  const std::string& server_hostname,
                  const QuicConfig& config,
                  const QuicVersionVector& supported_versions,
                  std::unique_ptr<ProofVerifier> proof_verifier);
 
   ~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);
 
-  // From SimpleClient
   // 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) override;
+  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);
-  ssize_t SendMessage(const HTTPMessage& message) override;
-  std::string SendCustomSynchronousRequest(const HTTPMessage& message) override;
-  std::string SendSynchronousRequest(const std::string& uri) override;
-  void Connect() override;
-  void ResetConnection() override;
-  void Disconnect() override;
-  IPEndPoint local_address() const override;
-  void ClearPerRequestState() override;
-  bool WaitUntil(int timeout_ms, std::function<bool()> trigger) override;
-  ssize_t Send(const void* buffer, size_t size) override;
-  bool response_complete() const override;
-  bool response_headers_complete() const override;
-  const BalsaHeaders* response_headers() const override;
-  int64_t response_size() const override;
-  int response_header_size() const override;
-  int64_t response_body_size() const override;
-  size_t bytes_read() const override;
-  size_t bytes_written() const override;
-  bool buffer_body() const override;
-  void set_buffer_body(bool buffer_body) override;
-  bool ServerInLameDuckMode() const override;
-  const std::string& response_body() override;
-  bool connected() const override;
-  // These functions are all unimplemented functions from SimpleClient, and log
-  // DFATAL if called by users of SimpleClient.
-  ssize_t SendAndWaitForResponse(const void* buffer, size_t size) override;
-  void Bind(IPEndPoint* local_address) override;
-  void MigrateSocket(const IPAddress& new_host) override;
-  std::string SerializeMessage(const HTTPMessage& message) override;
-  IPAddress bind_to_address() const override;
-  void set_bind_to_address(const IPAddress& address) override;
-  const IPEndPoint& address() const override;
-  size_t requests_sent() const override;
+  ssize_t SendMessage(const HTTPMessage& message);
+  std::string SendCustomSynchronousRequest(const HTTPMessage& message);
+  std::string SendSynchronousRequest(const std::string& uri);
+  void Connect();
+  void ResetConnection();
+  void Disconnect();
+  IPEndPoint local_address() const;
+  void ClearPerRequestState();
+  bool WaitUntil(int timeout_ms, std::function<bool()> trigger);
+  ssize_t Send(const void* buffer, size_t size);
+  bool response_complete() const;
+  bool response_headers_complete() const;
+  const BalsaHeaders* response_headers() const;
+  int64_t response_size() const;
+  int response_header_size() const;
+  int64_t response_body_size() const;
+  size_t bytes_read() const;
+  size_t bytes_written() const;
+  bool buffer_body() const;
+  void set_buffer_body(bool buffer_body);
+  const std::string& response_body();
+  bool connected() const;
+
+  // Returns once a complete response or a connection close has been received
+  // from the server.
+  void WaitForResponse() { WaitForResponseForMs(-1); }
+
+  // Waits for some data or response from the server.
+  void WaitForInitialResponse() { WaitForInitialResponseForMs(-1); }
+
+  // Returns once a complete response or a connection close has been received
+  // from the server, or once the timeout expires. -1 for no timeout.
+  void WaitForResponseForMs(int timeout_ms) {
+    WaitUntil(timeout_ms, [this]() { return response_complete(); });
+    if (response_complete()) {
+      VLOG(1) << "Client received response:"
+              << response_headers()->DebugString() << response_body();
+    }
+  }
+
+  // Waits for some data or response from the server, or once the timeout
+  // expires. -1 for no timeout.
+  void WaitForInitialResponseForMs(int timeout_ms) {
+    WaitUntil(timeout_ms, [this]() { return response_size() != 0; });
+  }
+
+  void MigrateSocket(const IPAddress& new_host);
+  IPAddress bind_to_address() const;
+  void set_bind_to_address(IPAddress address);
+  const IPEndPoint& address() const;
 
   // Returns the response trailers as received by the |stream_|.
   const SpdyHeaderBlock& response_trailers() const;
 
   // From QuicSpdyStream::Visitor
   void OnClose(QuicSpdyStream* stream) override;
 
   // From QuicClientPushPromiseIndex::Delegate
   bool CheckVary(const SpdyHeaderBlock& client_request,
                  const SpdyHeaderBlock& promise_request,
@@ skipping 58 matching lines @@
     client_->set_server_address(server_address);
   }
 
   // Explicitly set the SNI value for this client, overriding the default
   // behavior which extracts the SNI value from the request URL.
   void OverrideSni(const std::string& sni) {
     override_sni_set_ = true;
     override_sni_ = sni;
   }
 
- protected:
-  QuicTestClient();
-
   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),
@@ skipping 60 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_