Unify the QUIC client classes.

net/tools/quic/quic_simple_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_simple_client.h"
 
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_info.h"
+#include "net/http/http_response_info.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_default_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_server_id.h"
+#include "net/spdy/spdy_http_utils.h"
 #include "net/udp/udp_client_socket.h"
 
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
 
 QuicSimpleClient::QuicSimpleClient(IPEndPoint server_address,
                                    const QuicServerId& server_id,
@@ skipping 120 matching lines @@
 
   writer_.reset(CreateQuicPacketWriter());
   connection_ = new QuicConnection(GenerateConnectionId(),
                                    server_address_,
                                    helper_.get(),
                                    DummyPacketWriterFactory(writer_.get()),
                                    /* owns_writer= */ false,
                                    Perspective::IS_CLIENT,
                                    server_id_.is_https(),
                                    supported_versions_);
-  session_.reset(new QuicSimpleClientSession(config_, connection_));
+  session_.reset(new QuicClientSession(config_, connection_));
   session_->InitializeSession(server_id_, &crypto_config_);
   session_->CryptoConnect();
 }
 
 bool QuicSimpleClient::EncryptionBeingEstablished() {
   return !session_->IsEncryptionEstablished() &&
       session_->connection()->connected();
 }
 
 void QuicSimpleClient::Disconnect() {
   DCHECK(initialized_);
 
   if (connected()) {
     session()->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY);
   }
 
   writer_.reset();
   packet_reader_.reset();
 
   initialized_ = false;
 }
 
 void QuicSimpleClient::SendRequest(const HttpRequestInfo& headers,
                                    base::StringPiece body,
                                    bool fin) {
-  QuicSimpleClientStream* stream = CreateReliableClientStream();
+  QuicSpdyClientStream* stream = CreateReliableClientStream();
   if (stream == nullptr) {
     LOG(DFATAL) << "stream creation failed!";
     return;
   }
-  stream->SendRequest(headers, body, fin);
+  SpdyHeaderBlock header_block;
+  CreateSpdyHeadersFromHttpRequest(headers, headers.extra_headers, SPDY3, true,
+                                   &header_block);
+  stream->SendRequest(header_block, body, fin);
   stream->set_visitor(this);
 }
 
 void QuicSimpleClient::SendRequestAndWaitForResponse(
     const HttpRequestInfo& request,
     base::StringPiece body,
     bool fin) {
   SendRequest(request, body, fin);
   while (WaitForEvents()) {}
 }
 
 void QuicSimpleClient::SendRequestsAndWaitForResponse(
     const base::CommandLine::StringVector& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL(url_list[i]);
     SendRequest(request, "", true);
   }
 
   while (WaitForEvents()) {}
 }
 
-QuicSimpleClientStream* QuicSimpleClient::CreateReliableClientStream() {
+QuicSpdyClientStream* QuicSimpleClient::CreateReliableClientStream() {
   if (!connected()) {
     return nullptr;
   }
 
   return session_->CreateOutgoingDataStream();
 }
 
 void QuicSimpleClient::WaitForStreamToClose(QuicStreamId id) {
   DCHECK(connected());
 
@@ skipping 11 matching lines @@
 }
 
 bool QuicSimpleClient::WaitForEvents() {
   DCHECK(connected());
 
   base::RunLoop().RunUntilIdle();
   return session_->num_active_requests() != 0;
 }
 
 void QuicSimpleClient::OnClose(QuicDataStream* stream) {
-  QuicSimpleClientStream* client_stream =
-      static_cast<QuicSimpleClientStream*>(stream);
+  QuicSpdyClientStream* client_stream =
+      static_cast<QuicSpdyClientStream*>(stream);
+  HttpResponseInfo response;
+  SpdyHeadersToHttpResponse(client_stream->headers(), SPDY3, &response);
   if (response_listener_.get() != nullptr) {
     response_listener_->OnCompleteResponse(
-        stream->id(), *client_stream->headers(), client_stream->data());
+        stream->id(), *response.headers, client_stream->data());
   }
 
   // Store response headers and body.
   if (store_response_) {
-    latest_response_code_ = client_stream->headers()->response_code();
-    client_stream->headers()->GetNormalizedHeaders(&latest_response_headers_);
+    latest_response_code_ = client_stream->response_code();
+    response.headers->GetNormalizedHeaders(&latest_response_headers_);
     latest_response_body_ = client_stream->data();
   }
 }
 
 bool QuicSimpleClient::connected() const {
   return session_.get() && session_->connection() &&
       session_->connection()->connected();
 }
 
 bool QuicSimpleClient::goaway_received() const {
@@ skipping 41 matching lines @@
   session_->connection()->ProcessUdpPacket(local_address, peer_address, packet);
   if (!session_->connection()->connected()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace tools
 }  // namespace net