Introduce HttpStream and HttpBasicStream.

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 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/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/client_socket_factory.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/dns_resolution_observer.h"
 #include "net/base/host_resolver.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_client_socket.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
+#include "net/http/http_basic_stream.h"
 #include "net/http/http_chunked_decoder.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 using base::Time;
 
 namespace net {
 
@@ skipping 540 matching lines @@
     // needed.
     LogTCPConnectedMetrics();
     if (using_ssl_ && !using_tunnel_) {
       next_state_ = STATE_SSL_CONNECT;
     } else {
       next_state_ = STATE_WRITE_HEADERS;
       if (using_tunnel_)
         establishing_tunnel_ = true;
     }
   }
+  http_stream_.reset(new HttpBasicStream(&connection_));
   return OK;
 }
 
 int HttpNetworkTransaction::DoSSLConnect() {
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
 
   // Add a SSL socket on top of our existing transport socket.
   ClientSocket* s = connection_.release_socket();
   s = socket_factory_->CreateSSLClientSocket(
       s, request_->url.HostNoBrackets(), ssl_config_);
@@ skipping 55 matching lines @@
   // out the first bytes of the request headers.
   if (request_headers_bytes_sent_ == 0) {
     response_.request_time = Time::Now();
   }
 
   request_headers_->SetDataOffset(request_headers_bytes_sent_);
   int buf_len = static_cast<int>(request_headers_->headers_.size() -
                                  request_headers_bytes_sent_);
   DCHECK_GT(buf_len, 0);
 
-  return connection_.socket()->Write(request_headers_, buf_len, &io_callback_);
+  return http_stream_->Write(request_headers_, buf_len, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoWriteHeadersComplete(int result) {
   if (result < 0)
     return HandleIOError(result);
 
   request_headers_bytes_sent_ += result;
   if (request_headers_bytes_sent_ < request_headers_->headers_.size()) {
     next_state_ = STATE_WRITE_HEADERS;
   } else if (!establishing_tunnel_ && request_body_stream_.get() &&
              request_body_stream_->size()) {
     next_state_ = STATE_WRITE_BODY;
   } else {
     next_state_ = STATE_READ_HEADERS;
   }
   return OK;
 }
 
 int HttpNetworkTransaction::DoWriteBody() {
   next_state_ = STATE_WRITE_BODY_COMPLETE;
 
   DCHECK(request_body_stream_.get());
   DCHECK(request_body_stream_->size());
 
   int buf_len = static_cast<int>(request_body_stream_->buf_len());
 
-  return connection_.socket()->Write(request_body_stream_->buf(), buf_len,
-                                     &io_callback_);
+  return http_stream_->Write(request_body_stream_->buf(), buf_len,
+                             &io_callback_);
 }
 
 int HttpNetworkTransaction::DoWriteBodyComplete(int result) {
   if (result < 0)
     return HandleIOError(result);
 
   request_body_stream_->DidConsume(result);
 
   if (request_body_stream_->position() < request_body_stream_->size()) {
     next_state_ = STATE_WRITE_BODY;
   } else {
     next_state_ = STATE_READ_HEADERS;
   }
   return OK;
 }
 
 int HttpNetworkTransaction::DoReadHeaders() {
   next_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
   if (header_buf_len_ == header_buf_capacity_) {
     header_buf_capacity_ += kHeaderBufInitialSize;
     header_buf_->Realloc(header_buf_capacity_);
   }
 
   int buf_len = header_buf_capacity_ - header_buf_len_;
   header_buf_->set_data(header_buf_len_);
 
-  return connection_.socket()->Read(header_buf_, buf_len, &io_callback_);
+  return http_stream_->Read(header_buf_, buf_len, &io_callback_);
 }
 
 int HttpNetworkTransaction::HandleConnectionClosedBeforeEndOfHeaders() {
   if (establishing_tunnel_) {
     // The connection was closed before the tunnel could be established.
     return ERR_TUNNEL_CONNECTION_FAILED;
   }
 
   if (has_found_status_line_start()) {
     // Assume EOF is end-of-headers.
@@ skipping 110 matching lines @@
     if (header_buf_body_offset_ == header_buf_len_) {
       header_buf_->Reset();
       header_buf_capacity_ = 0;
       header_buf_len_ = 0;
       header_buf_body_offset_ = -1;
     }
     return n;
   }
 
   reading_body_from_socket_ = true;
-  return connection_.socket()->Read(read_buf_, read_buf_len_, &io_callback_);
+  return http_stream_->Read(read_buf_, read_buf_len_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
   // We are done with the Read call.
   DCHECK(!establishing_tunnel_) <<
       "We should never read a response body of a tunnel.";
 
   bool unfiltered_eof = (result == 0 && reading_body_from_socket_);
   reading_body_from_socket_ = false;
 
@@ skipping 766 matching lines @@
     host_and_port = proxy_info_.proxy_server().host_and_port();
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     host_and_port = GetHostAndPort(request_->url);
   }
   auth_info->host_and_port = ASCIIToWide(host_and_port);
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net