Add better help information to quic_client and quic_server. Also,

net/tools/quic/quic_client.cc

 // 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.
 
 #include "net/tools/quic/quic_client.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
@@ skipping 14 matching lines @@
 #define SO_RXQ_OVFL 40
 #endif
 
 namespace net {
 namespace tools {
 
 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
 
 QuicClient::QuicClient(IPEndPoint server_address,
                        const string& server_hostname,
-                       const QuicVersion version)
+                       const QuicVersion version,
+                       bool print_response)
     : server_address_(server_address),
       server_hostname_(server_hostname),
       local_port_(0),
       fd_(-1),
       initialized_(false),
       packets_dropped_(0),
       overflow_supported_(false),
-      version_(version) {
+      version_(version),
+      print_response_(print_response) {
   config_.SetDefaults();
 }
 
 QuicClient::QuicClient(IPEndPoint server_address,
                        const string& server_hostname,
                        const QuicConfig& config,
                        const QuicVersion version)
     : server_address_(server_address),
       server_hostname_(server_hostname),
       config_(config),
       local_port_(0),
       fd_(-1),
       initialized_(false),
       packets_dropped_(0),
       overflow_supported_(false),
-      version_(version) {
+      version_(version),
+      print_response_(false) {
 }
 
 QuicClient::~QuicClient() {
   if (connected()) {
     session()->connection()->SendConnectionClosePacket(
         QUIC_PEER_GOING_AWAY, "");
   }
 }
 
 bool QuicClient::Initialize() {
@@ skipping 101 matching lines @@
 
   session()->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY);
   epoll_server_.UnregisterFD(fd_);
   close(fd_);
   fd_ = -1;
   initialized_ = false;
 }
 
 void QuicClient::SendRequestsAndWaitForResponse(
     const CommandLine::StringVector& args) {
-  for (uint32_t i = 0; i < args.size(); i++) {
+  for (size_t i = 0; i < args.size(); i++) {
     BalsaHeaders headers;
     headers.SetRequestFirstlineFromStringPieces("GET", args[i], "HTTP/1.1");
-    CreateReliableClientStream()->SendRequest(headers, "", true);
+    QuicReliableClientStream* stream = CreateReliableClientStream();
+    stream->SendRequest(headers, "", true);
+    stream->set_visitor(this);
   }
 
   while (WaitForEvents()) { }
 }
 
 QuicReliableClientStream* QuicClient::CreateReliableClientStream() {
   if (!connected()) {
     return NULL;
   }
 
@@ skipping 31 matching lines @@
     }
   }
   if (connected() && (event->in_events & EPOLLOUT)) {
     session_->connection()->OnCanWrite();
   }
   if (event->in_events & EPOLLERR) {
     DLOG(INFO) << "Epollerr";
   }
 }
 
+void QuicClient::OnClose(ReliableQuicStream* stream) {
+  if (!print_response_) {
+    return;
+  }
+
+  QuicReliableClientStream* client_stream =
+      static_cast<QuicReliableClientStream*>(stream);
+  const BalsaHeaders& headers = client_stream->headers();
+  printf("%s\n", headers.first_line().as_string().c_str());
+  for (BalsaHeaders::const_header_lines_iterator i =
+           headers.header_lines_begin();
+       i != headers.header_lines_end(); ++i) {
+    printf("%s: %s\n", i->first.as_string().c_str(),
+           i->second.as_string().c_str());
+  }
+  printf("%s\n", client_stream->data().c_str());
+}
+
 QuicPacketCreator::Options* QuicClient::options() {
   if (session() == NULL) {
     return NULL;
   }
   return session_->options();
 }
 
 bool QuicClient::connected() const {
   return session_.get() && session_->connection() &&
       session_->connection()->connected();
@@ skipping 34 matching lines @@
   }
 
   IPEndPoint client_address(client_ip, client_address_.port());
   session_->connection()->ProcessUdpPacket(
       client_address, server_address, packet);
   return true;
 }
 
 }  // namespace tools
 }  // namespace net