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 "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 10 matching lines @@
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/http_message.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
 using net::QuicServerId;
 using net::test::QuicConnectionPeer;
 using net::test::QuicSessionPeer;
 using net::test::ReliableQuicStreamPeer;
-using net::test::kInitialFlowControlWindowForTest;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
 // RecordingProofVerifier accepts any certificate chain and records the common
 // name of the leaf.
@@ skipping 55 matching lines @@
                                "http://www.google.com";
     full_uri.append(uri.as_string());
     headers->SetRequestUri(full_uri);
   }
   return headers;
 }
 
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
-    const QuicVersionVector& supported_versions)
+    const QuicVersionVector& supported_versions,
+    EpollServer* epoll_server)
     : QuicClient(server_address,
                  server_id,
                  supported_versions,
-                 false),
+                 false,
+                 epoll_server),
       override_connection_id_(0),
       test_writer_(NULL) {}
 
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicConfig& config,
-    const QuicVersionVector& supported_versions)
+    const QuicVersionVector& supported_versions,
+    EpollServer* epoll_server)
     : QuicClient(server_address,
                  server_id,
                  supported_versions,
                  false,
-                 config),
+                 config,
+                 epoll_server),
       override_connection_id_(0),
       test_writer_(NULL) {}
 
 MockableQuicClient::~MockableQuicClient() {
   if (connected()) {
     Disconnect();
   }
 }
 
 QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() {
@@ skipping 21 matching lines @@
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint server_address,
                                const string& server_hostname,
                                const QuicVersionVector& supported_versions)
     : client_(new MockableQuicClient(server_address,
                                      QuicServerId(server_hostname,
                                                   server_address.port(),
                                                   false,
                                                   PRIVACY_MODE_DISABLED),
-                                     supported_versions)) {
+                                     supported_versions,
+                                     &epoll_server_)) {
   Initialize(true);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint server_address,
                                const string& server_hostname,
                                bool secure,
                                const QuicVersionVector& supported_versions)
     : client_(new MockableQuicClient(server_address,
                                      QuicServerId(server_hostname,
                                                   server_address.port(),
                                                   secure,
                                                   PRIVACY_MODE_DISABLED),
-                                     supported_versions)) {
+                                     supported_versions,
+                                     &epoll_server_)) {
   Initialize(secure);
 }
 
 QuicTestClient::QuicTestClient(
     IPEndPoint server_address,
     const string& server_hostname,
     bool secure,
     const QuicConfig& config,
     const QuicVersionVector& supported_versions)
     : client_(
           new MockableQuicClient(server_address,
                                  QuicServerId(server_hostname,
                                               server_address.port(),
                                               secure,
                                               PRIVACY_MODE_DISABLED),
                                  config,
-                                 supported_versions)) {
+                                 supported_versions,
+                                 &epoll_server_)) {
   Initialize(secure);
 }
 
 QuicTestClient::QuicTestClient() {
 }
 
 QuicTestClient::~QuicTestClient() {
   if (stream_) {
     stream_->set_visitor(NULL);
   }
@@ skipping 14 matching lines @@
 void QuicTestClient::ExpectCertificates(bool on) {
   if (on) {
     proof_verifier_ = new RecordingProofVerifier;
     client_->SetProofVerifier(proof_verifier_);
   } else {
     proof_verifier_ = NULL;
     client_->SetProofVerifier(NULL);
   }
 }
 
+void QuicTestClient::SetUserAgentID(const string& user_agent_id) {
+  client_->SetUserAgentID(user_agent_id);
+}
+
 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.
 
@@ skipping 156 matching lines @@
   response_headers_complete_ = false;
   headers_.Clear();
   bytes_read_ = 0;
   bytes_written_ = 0;
   response_header_size_ = 0;
   response_body_size_ = 0;
 }
 
 void QuicTestClient::WaitForResponseForMs(int timeout_ms) {
   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
-  int64 old_timeout_us = client()->epoll_server()->timeout_in_us();
+  int64 old_timeout_us = epoll_server()->timeout_in_us();
   if (timeout_us > 0) {
-    client()->epoll_server()->set_timeout_in_us(timeout_us);
+    epoll_server()->set_timeout_in_us(timeout_us);
   }
   const QuicClock* clock =
       QuicConnectionPeer::GetHelper(client()->session()->connection())->
           GetClock();
   QuicTime end_waiting_time = clock->Now().Add(
       QuicTime::Delta::FromMicroseconds(timeout_us));
   while (stream_ != NULL &&
          !client_->session()->IsClosedStream(stream_->id()) &&
          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
     client_->WaitForEvents();
   }
   if (timeout_us > 0) {
-    client()->epoll_server()->set_timeout_in_us(old_timeout_us);
+    epoll_server()->set_timeout_in_us(old_timeout_us);
   }
 }
 
 void QuicTestClient::WaitForInitialResponseForMs(int timeout_ms) {
   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
-  int64 old_timeout_us = client()->epoll_server()->timeout_in_us();
+  int64 old_timeout_us = epoll_server()->timeout_in_us();
   if (timeout_us > 0) {
-    client()->epoll_server()->set_timeout_in_us(timeout_us);
+    epoll_server()->set_timeout_in_us(timeout_us);
   }
   const QuicClock* clock =
       QuicConnectionPeer::GetHelper(client()->session()->connection())->
           GetClock();
   QuicTime end_waiting_time = clock->Now().Add(
       QuicTime::Delta::FromMicroseconds(timeout_us));
   while (stream_ != NULL &&
          !client_->session()->IsClosedStream(stream_->id()) &&
          stream_->stream_bytes_read() == 0 &&
          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
     client_->WaitForEvents();
   }
   if (timeout_us > 0) {
-    client()->epoll_server()->set_timeout_in_us(old_timeout_us);
+    epoll_server()->set_timeout_in_us(old_timeout_us);
   }
 }
 
 ssize_t QuicTestClient::Send(const void *buffer, size_t size) {
   return SendData(string(static_cast<const char*>(buffer), size), false);
 }
 
 bool QuicTestClient::response_headers_complete() const {
   if (stream_ != NULL) {
     return stream_->headers_decompressed();
@@ skipping 95 matching lines @@
   // Set policy for headers and crypto streams.
   ReliableQuicStreamPeer::SetFecPolicy(
       QuicSessionPeer::GetHeadersStream(client()->session()), fec_policy);
   ReliableQuicStreamPeer::SetFecPolicy(client()->session()->GetCryptoStream(),
                                        fec_policy);
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net