Updates quic_client_bin.cc to be more user friendly, and support more

net/tools/quic/quic_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_CLIENT_H_
 #define NET_TOOLS_QUIC_QUIC_CLIENT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string_piece.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/quic_config.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
+#include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_client_session.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 
 namespace net {
 
 class ProofVerifier;
 class QuicServerId;
 
 namespace tools {
@@ skipping 14 matching lines @@
     virtual void OnCompleteResponse(QuicStreamId id,
                                     const BalsaHeaders& response_headers,
                                     const std::string& response_body) = 0;
   };
 
   // Create a quic client, which will have events managed by an externally owned
   // EpollServer.
   QuicClient(IPEndPoint server_address,
              const QuicServerId& server_id,
              const QuicVersionVector& supported_versions,
-             bool print_response,
              EpollServer* epoll_server);
   QuicClient(IPEndPoint server_address,
              const QuicServerId& server_id,
              const QuicVersionVector& supported_versions,
-             bool print_response,
              const QuicConfig& config,
              EpollServer* epoll_server);
 
   ~QuicClient() override;
 
   // Initializes the client to create a connection. Should be called exactly
   // once before calling StartConnect or Connect. Returns true if the
   // initialization succeeds, false otherwise.
   bool Initialize();
 
   // "Connect" to the QUIC server, including performing synchronous crypto
   // handshake.
   bool Connect();
 
   // Start the crypto handshake.  This can be done in place of the synchronous
   // Connect(), but callers are responsible for making sure the crypto handshake
   // completes.
   void StartConnect();
 
   // Returns true if the crypto handshake has yet to establish encryption.
   // Returns false if encryption is active (even if the server hasn't confirmed
   // the handshake) or if the connection has been closed.
   bool EncryptionBeingEstablished();
 
   // Disconnects from the QUIC server.
   void Disconnect();
 
+  // Sends an HTTP request and does not wait for response before returning.
+  void SendRequest(const BalsaHeaders& headers,
+                   base::StringPiece body,
+                   bool fin);
+
+  // Sends an HTTP request and waits for response before returning.
+  void SendRequestAndWaitForResponse(const BalsaHeaders& 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& args);
 
   // Returns a newly created QuicSpdyClientStream, owned by the
   // QuicClient.
   QuicSpdyClientStream* CreateReliableClientStream();
 
   // Wait for events until the stream with the given ID is closed.
@@ skipping 68 matching lines @@
     supported_versions_ = versions;
   }
 
   // Takes ownership of the listener.
   void set_response_listener(ResponseListener* listener) {
     response_listener_.reset(listener);
   }
 
   QuicConfig* config() { return &config_; }
 
+  void set_store_response(bool val) { store_response_ = val; }
+
+  size_t latest_response_code() const;
+  const std::string& latest_response_headers() const;
+  const std::string& latest_response_body() const;
+
  protected:
   virtual QuicConnectionId GenerateConnectionId();
   virtual QuicEpollConnectionHelper* CreateQuicConnectionHelper();
   virtual QuicPacketWriter* CreateQuicPacketWriter();
 
   virtual int ReadPacket(char* buffer,
                          int buffer_len,
                          IPEndPoint* server_address,
                          IPAddressNumber* client_ip);
 
@@ skipping 71 matching lines @@
   // because the socket would otherwise overflow.
   bool overflow_supported_;
 
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
   // element, with subsequent elements in descending order (versions can be
   // skipped as necessary). We will always pick supported_versions_[0] as the
   // initial version to use.
   QuicVersionVector supported_versions_;
 
-  // If true, then the contents of each response will be printed to stdout
-  // when the stream is closed (in OnClose).
-  bool print_response_;
+  // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicClient);
 };
 
 }  // namespace tools
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_CLIENT_H_