Land Recent QUIC changes.

net/tools/quic/test_tools/quic_test_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/test_tools/quic_test_client.h"
 
 #include "googleurl/src/gurl.h"
 #include "net/tools/flip_server/balsa_headers.h"
 #include "net/tools/quic/test_tools/http_message_test_utils.h"
 
 using std::string;
 using base::StringPiece;
 
 namespace net {
 namespace tools {
 namespace test {
 
-BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers) {
+BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers,
+                           bool secure) {
   StringPiece uri = const_headers->request_uri();
   if (uri.empty()) {
     return NULL;
   }
   if (const_headers->request_method() == "CONNECT") {
     return NULL;
   }
   BalsaHeaders* headers = new BalsaHeaders;
   headers->CopyFrom(*const_headers);
   if (!uri.starts_with("https://") &&
       !uri.starts_with("http://")) {
     // If we have a relative URL, set some defaults.
-    string full_uri = "https:/www.google.com";
+    string full_uri = secure ? "https://www.google.com" :
+                               "http://www.google.com";
     full_uri.append(uri.as_string());
     headers->SetRequestUri(full_uri);
   }
   return headers;
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address, const string& hostname)
-    : server_address_(address),
-      client_(address, hostname),
-      stream_(NULL),
-      stream_error_(QUIC_STREAM_NO_ERROR),
-      connection_error_(QUIC_NO_ERROR),
-      bytes_read_(0),
-      bytes_written_(0),
-      never_connected_(true) {
+    : client_(address, hostname) {
+  Initialize(address, hostname);
+}
+
+QuicTestClient::QuicTestClient(IPEndPoint address,
+                               const string& hostname,
+                               bool secure)
+    : client_(address, hostname) {
+  Initialize(address, hostname);
+  secure_ = secure;
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
                                const string& hostname,
                                const QuicConfig& config)
-    : server_address_(address),
-      client_(address, hostname, config),
-      stream_(NULL),
-      stream_error_(QUIC_STREAM_NO_ERROR),
-      connection_error_(QUIC_NO_ERROR),
-      bytes_read_(0),
-      bytes_written_(0),
-      never_connected_(true) {
+    : client_(address, hostname, config) {
+  Initialize(address, hostname);
+}
+
+void QuicTestClient::Initialize(IPEndPoint address, const string& hostname) {
+  server_address_ = address;
+  stream_ = NULL;
+  stream_error_ = QUIC_STREAM_NO_ERROR;
+  connection_error_ = QUIC_NO_ERROR;
+  bytes_read_ = 0;
+  bytes_written_= 0;
+  never_connected_ =true;
+  secure_ = true;
+  auto_reconnect_ = false;
 }
 
 QuicTestClient::~QuicTestClient() {
   if (stream_) {
     stream_->set_visitor(NULL);
   }
 }
 
 ssize_t QuicTestClient::SendRequest(const string& uri) {
   HTTPMessage message(HttpConstants::HTTP_1_1, HttpConstants::GET, uri);
   return SendMessage(message);
 }
 
 ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) {
   stream_ = NULL;  // Always force creation of a stream for SendMessage.
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
     GURL url(message.headers()->request_uri().as_string());
     if (!url.host().empty()) {
       client_.set_server_hostname(url.host());
     }
   }
 
   QuicReliableClientStream* stream = GetOrCreateStream();
   if (!stream) { return 0; }
 
-  scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers()));
+  scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(),
+                                          secure_));
   return GetOrCreateStream()->SendRequest(
       munged_headers.get() ? *munged_headers.get() : *message.headers(),
       message.body(),
       message.has_complete_message());
 }
 
 ssize_t QuicTestClient::SendData(string data, bool last_data) {
   QuicReliableClientStream* stream = GetOrCreateStream();
   if (!stream) { return 0; }
   GetOrCreateStream()->SendBody(data, last_data);
@@ skipping 10 matching lines @@
 string QuicTestClient::SendSynchronousRequest(const string& uri) {
   if (SendRequest(uri) == 0) {
     DLOG(ERROR) << "Failed the request for uri:" << uri;
     return "";
   }
   WaitForResponse();
   return response_;
 }
 
 QuicReliableClientStream* QuicTestClient::GetOrCreateStream() {
-  if (never_connected_ == true) {
+  if (never_connected_ == true || auto_reconnect_) {
     if (!connected()) {
       Connect();
     }
     if (!connected()) {
       return NULL;
     }
   }
   if (!stream_) {
     stream_ = client_.CreateReliableClientStream();
-    stream_->set_visitor(this);
+    if (stream_ != NULL) {
+      stream_->set_visitor(this);
+    }
   }
   return stream_;
 }
 
 bool QuicTestClient::connected() const {
   return client_.connected();
 }
 
 void QuicTestClient::WaitForResponse() {
+  if (stream_ == NULL) {
+    // The client has likely disconnected.
+    return;
+  }
   client_.WaitForStreamToClose(stream_->id());
 }
 
 void QuicTestClient::Connect() {
   DCHECK(!connected());
   client_.Initialize();
   client_.Connect();
   never_connected_ = false;
 }
 
@@ skipping 52 matching lines @@
   stream_error_ = stream_->stream_error();
   connection_error_ = stream_->connection_error();
   bytes_read_ = stream_->stream_bytes_read();
   bytes_written_ = stream_->stream_bytes_written();
   stream_ = NULL;
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net