Extend the use of IOBuffers to the code underneath...

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"
@@ skipping 13 matching lines @@
 #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 {
 
+void HttpNetworkTransaction::ResponseHeaders::Realloc(size_t new_size) {
+  headers_.reset(static_cast<char*>(realloc(headers_.release(), new_size)));
+}
+
 //-----------------------------------------------------------------------------
 
 HttpNetworkTransaction::HttpNetworkTransaction(HttpNetworkSession* session,
                                                ClientSocketFactory* csf)
     : pending_auth_target_(HttpAuth::AUTH_NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &HttpNetworkTransaction::OnIOComplete)),
       user_callback_(NULL),
       session_(session),
       request_(NULL),
       pac_request_(NULL),
       socket_factory_(csf),
       connection_(session->connection_pool()),
       reused_socket_(false),
       using_ssl_(false),
       using_proxy_(false),
       using_tunnel_(false),
       establishing_tunnel_(false),
       reading_body_from_socket_(false),
+      request_headers_(new RequestHeaders()),
       request_headers_bytes_sent_(0),
+      header_buf_(new ResponseHeaders()),
       header_buf_capacity_(0),
       header_buf_len_(0),
       header_buf_body_offset_(-1),
       header_buf_http_offset_(-1),
       response_body_length_(-1),  // -1 means unspecified.
       response_body_read_(0),
       read_buf_len_(0),
       next_state_(STATE_NONE) {
 #if defined(OS_WIN)
   // TODO(port): Port the SSLConfigService class to Linux and Mac OS X.
@@ skipping 227 matching lines @@
     session_->proxy_service()->CancelPacRequest(pac_request_);
 }
 
 void HttpNetworkTransaction::BuildRequestHeaders() {
   // For proxy use the full url. Otherwise just the absolute path.
   // This strips out any reference/username/password.
   std::string path = using_proxy_ ?
       HttpUtil::SpecForRequest(request_->url) :
       HttpUtil::PathForRequest(request_->url);
 
-  request_headers_ = request_->method + " " + path +
+  request_headers_->headers_ = request_->method + " " + path +
       " HTTP/1.1\r\nHost: " + request_->url.host();
   if (request_->url.IntPort() != -1)
-    request_headers_ += ":" + request_->url.port();
-  request_headers_ += "\r\n";
+    request_headers_->headers_ += ":" + request_->url.port();
+  request_headers_->headers_ += "\r\n";
 
   // For compat with HTTP/1.0 servers and proxies:
   if (using_proxy_)
-    request_headers_ += "Proxy-";
-  request_headers_ += "Connection: keep-alive\r\n";
+    request_headers_->headers_ += "Proxy-";
+  request_headers_->headers_ += "Connection: keep-alive\r\n";
 
   if (!request_->user_agent.empty())
-    request_headers_ += "User-Agent: " + request_->user_agent + "\r\n";
+    request_headers_->headers_ += "User-Agent: " + request_->user_agent +
+                                   "\r\n";
 
   // Our consumer should have made sure that this is a safe referrer.  See for
   // instance WebCore::FrameLoader::HideReferrer.
   if (request_->referrer.is_valid())
-    request_headers_ += "Referer: " + request_->referrer.spec() + "\r\n";
+    request_headers_->headers_ += "Referer: " + request_->referrer.spec() +
+                                   "\r\n";
 
   // Add a content length header?
   if (request_->upload_data) {
     request_body_stream_.reset(new UploadDataStream(request_->upload_data));
-    request_headers_ +=
+    request_headers_->headers_ +=
         "Content-Length: " + Uint64ToString(request_body_stream_->size()) +
         "\r\n";
   } else if (request_->method == "POST" || request_->method == "PUT" ||
              request_->method == "HEAD") {
     // An empty POST/PUT request still needs a content length.  As for HEAD,
     // IE and Safari also add a content length header.  Presumably it is to
     // support sending a HEAD request to an URL that only expects to be sent a
     // POST or some other method that normally would have a message body.
-    request_headers_ += "Content-Length: 0\r\n";
+    request_headers_->headers_ += "Content-Length: 0\r\n";
   }
 
   // Honor load flags that impact proxy caches.
   if (request_->load_flags & LOAD_BYPASS_CACHE) {
-    request_headers_ += "Pragma: no-cache\r\nCache-Control: no-cache\r\n";
+    request_headers_->headers_ +=
+        "Pragma: no-cache\r\nCache-Control: no-cache\r\n";
   } else if (request_->load_flags & LOAD_VALIDATE_CACHE) {
-    request_headers_ += "Cache-Control: max-age=0\r\n";
+    request_headers_->headers_ += "Cache-Control: max-age=0\r\n";
   }
 
   ApplyAuth();
 
   // TODO(darin): Need to prune out duplicate headers.
 
-  request_headers_ += request_->extra_headers;
-  request_headers_ += "\r\n";
+  request_headers_->headers_ += request_->extra_headers;
+  request_headers_->headers_ += "\r\n";
 }
 
 // The HTTP CONNECT method for establishing a tunnel connection is documented
 // in draft-luotonen-web-proxy-tunneling-01.txt and RFC 2817, Sections 5.2 and
 // 5.3.
 void HttpNetworkTransaction::BuildTunnelRequest() {
   // RFC 2616 Section 9 says the Host request-header field MUST accompany all
   // HTTP/1.1 requests.
-  request_headers_ = StringPrintf("CONNECT %s:%d HTTP/1.1\r\n",
+  request_headers_->headers_ = StringPrintf("CONNECT %s:%d HTTP/1.1\r\n",
       request_->url.host().c_str(), request_->url.EffectiveIntPort());
-  request_headers_ += "Host: " + request_->url.host();
+  request_headers_->headers_ += "Host: " + request_->url.host();
   if (request_->url.has_port())
-    request_headers_ += ":" + request_->url.port();
-  request_headers_ += "\r\n";
+    request_headers_->headers_ += ":" + request_->url.port();
+  request_headers_->headers_ += "\r\n";
 
   if (!request_->user_agent.empty())
-    request_headers_ += "User-Agent: " + request_->user_agent + "\r\n";
+    request_headers_->headers_ += "User-Agent: " + request_->user_agent +
+                                   "\r\n";
 
   ApplyAuth();
 
-  request_headers_ += "\r\n";
+  request_headers_->headers_ += "\r\n";
 }
 
 void HttpNetworkTransaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(user_callback_);
 
   // Since Run may result in Read being called, clear user_callback_ up front.
   CompletionCallback* c = user_callback_;
   user_callback_ = NULL;
   c->Run(rv);
@@ skipping 268 matching lines @@
     result = HandleSSLHandshakeError(result);
   }
   return result;
 }
 
 int HttpNetworkTransaction::DoWriteHeaders() {
   next_state_ = STATE_WRITE_HEADERS_COMPLETE;
 
   // This is constructed lazily (instead of within our Start method), so that
   // we have proxy info available.
-  if (request_headers_.empty()) {
+  if (request_headers_->headers_.empty()) {
     if (establishing_tunnel_) {
       BuildTunnelRequest();
     } else {
       BuildRequestHeaders();
     }
   }
 
   // Record our best estimate of the 'request time' as the time when we send
   // out the first bytes of the request headers.
   if (request_headers_bytes_sent_ == 0) {
     response_.request_time = Time::Now();
   }
 
-  const char* buf = request_headers_.data() + request_headers_bytes_sent_;
-  int buf_len = static_cast<int>(request_headers_.size() -
+  request_headers_->SetDataOffset(request_headers_bytes_sent_);
+  int buf_len = static_cast<int>(request_headers_->headers_.size() -
                                  request_headers_bytes_sent_);
   DCHECK(buf_len > 0);
 
-  return connection_.socket()->Write(buf, buf_len, &io_callback_);
+  return connection_.socket()->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_.size()) {
+  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());
 
   const char* buf = request_body_stream_->buf();
   int buf_len = static_cast<int>(request_body_stream_->buf_len());
+  DCHECK(!write_buffer_);
+  write_buffer_ = new IOBuffer(buf_len);
+  memcpy(write_buffer_->data(), buf, buf_len);
 
-  return connection_.socket()->Write(buf, buf_len, &io_callback_);
+  return connection_.socket()->Write(write_buffer_, buf_len, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoWriteBodyComplete(int result) {
+  DCHECK(write_buffer_);
+  write_buffer_ = NULL;
+
   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_.reset(static_cast<char*>(
-        realloc(header_buf_.release(), header_buf_capacity_)));
+    header_buf_->Realloc(header_buf_capacity_);
   }
 
-  char* buf = header_buf_.get() + header_buf_len_;
   int buf_len = header_buf_capacity_ - header_buf_len_;
+  header_buf_->set_data(header_buf_len_);
 
-  return connection_.socket()->Read(buf, buf_len, &io_callback_);
+  return connection_.socket()->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 40 matching lines @@
     int rv = HandleConnectionClosedBeforeEndOfHeaders();
     if (rv != OK)
       return rv;
   } else {
     header_buf_len_ += result;
     DCHECK(header_buf_len_ <= header_buf_capacity_);
 
     // Look for the start of the status line, if it hasn't been found yet.
     if (!has_found_status_line_start()) {
       header_buf_http_offset_ = HttpUtil::LocateStartOfStatusLine(
-          header_buf_.get(), header_buf_len_);
+          header_buf_->headers(), header_buf_len_);
     }
 
     if (has_found_status_line_start()) {
       int eoh = HttpUtil::LocateEndOfHeaders(
-          header_buf_.get(), header_buf_len_, header_buf_http_offset_);
+          header_buf_->headers(), header_buf_len_, header_buf_http_offset_);
       if (eoh == -1) {
         // Prevent growing the headers buffer indefinitely.
         if (header_buf_len_ >= kMaxHeaderBufSize)
           return ERR_RESPONSE_HEADERS_TOO_BIG;
 
         // Haven't found the end of headers yet, keep reading.
         next_state_ = STATE_READ_HEADERS;
         return OK;
       }
       header_buf_body_offset_ = eoh;
@@ skipping 18 matching lines @@
   DCHECK(connection_.is_initialized());
 
   next_state_ = STATE_READ_BODY_COMPLETE;
 
   // We may have already consumed the indicated content length.
   if (response_body_length_ != -1 &&
       response_body_read_ >= response_body_length_)
     return 0;
 
   // We may have some data remaining in the header buffer.
-  if (header_buf_.get() && header_buf_body_offset_ < header_buf_len_) {
+  if (header_buf_->headers() && header_buf_body_offset_ < header_buf_len_) {
     int n = std::min(read_buf_len_, header_buf_len_ - header_buf_body_offset_);
-    memcpy(read_buf_->data(), header_buf_.get() + header_buf_body_offset_, n);
+    memcpy(read_buf_->data(), header_buf_->headers() + header_buf_body_offset_,
+           n);
     header_buf_body_offset_ += n;
     if (header_buf_body_offset_ == header_buf_len_) {
-      header_buf_.reset();
+      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_->data(), read_buf_len_,
-                                    &io_callback_);
+  return connection_.socket()->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 187 matching lines @@
   LOG(WARNING) << "Blocked proxy response with status " << response_code
                << " to CONNECT request for " << request_->url.host() << ":"
                << request_->url.EffectiveIntPort() << ".";
 }
 
 int HttpNetworkTransaction::DidReadResponseHeaders() {
   scoped_refptr<HttpResponseHeaders> headers;
   if (has_found_status_line_start()) {
     headers = new HttpResponseHeaders(
         HttpUtil::AssembleRawHeaders(
-            header_buf_.get(), header_buf_body_offset_));
+            header_buf_->headers(), header_buf_body_offset_));
   } else {
     // Fabricate a status line to to preserve the HTTP/0.9 version.
     // (otherwise HttpResponseHeaders will default it to HTTP/1.0).
     headers = new HttpResponseHeaders(std::string("HTTP/0.9 200 OK"));
   }
 
   if (headers->GetParsedHttpVersion() < HttpVersion(1, 0)) {
     // Require the "HTTP/1.x" status line for SSL CONNECT.
     if (establishing_tunnel_)
       return ERR_TUNNEL_CONNECTION_FAILED;
 
     // HTTP/0.9 doesn't support the PUT method, so lack of response headers
     // indicates a buggy server.  See:
     // https://bugzilla.mozilla.org/show_bug.cgi?id=193921
     if (request_->method == "PUT")
       return ERR_METHOD_NOT_SUPPORTED;
   }
 
   if (establishing_tunnel_) {
     switch (headers->response_code()) {
       case 200:  // OK
         if (header_buf_body_offset_ != header_buf_len_) {
           // The proxy sent extraneous data after the headers.
           return ERR_TUNNEL_CONNECTION_FAILED;
         }
         next_state_ = STATE_SSL_CONNECT;
         // Reset for the real request and response headers.
-        request_headers_.clear();
+        request_headers_->headers_.clear();
         request_headers_bytes_sent_ = 0;
         header_buf_len_ = 0;
         header_buf_body_offset_ = 0;
         establishing_tunnel_ = false;
         return OK;
 
       // We aren't able to CONNECT to the remote host through the proxy.  We
       // need to be very suspicious about the response because an active network
       // attacker can force us into this state by masquerading as the proxy.
       // The only safe thing to do here is to fail the connection because our
@@ skipping 19 matching lines @@
   // Check for an intermediate 100 Continue response.  An origin server is
   // allowed to send this response even if we didn't ask for it, so we just
   // need to skip over it.
   // We treat any other 1xx in this same way (although in practice getting
   // a 1xx that isn't a 100 is rare).
   if (headers->response_code() / 100 == 1) {
     header_buf_len_ -= header_buf_body_offset_;
     // If we've already received some bytes after the 1xx response,
     // move them to the beginning of header_buf_.
     if (header_buf_len_) {
-      memmove(header_buf_.get(), header_buf_.get() + header_buf_body_offset_,
+      memmove(header_buf_->headers(),
+              header_buf_->headers() + header_buf_body_offset_,
               header_buf_len_);
     }
     header_buf_body_offset_ = -1;
     next_state_ = STATE_READ_HEADERS;
     return OK;
   }
 
   response_.headers = headers;
   response_.vary_data.Init(*request_, *response_.headers);
 
@@ skipping 118 matching lines @@
     case ERR_CONNECTION_ABORTED:
       if (ShouldResendRequest())
         error = OK;
       break;
   }
   return error;
 }
 
 void HttpNetworkTransaction::ResetStateForRestart() {
   pending_auth_target_ = HttpAuth::AUTH_NONE;
-  header_buf_.reset();
+  header_buf_->Reset();
   header_buf_capacity_ = 0;
   header_buf_len_ = 0;
   header_buf_body_offset_ = -1;
   header_buf_http_offset_ = -1;
   response_body_length_ = -1;
   response_body_read_ = 0;
   read_buf_ = NULL;
   read_buf_len_ = 0;
-  request_headers_.clear();
+  request_headers_->headers_.clear();
   request_headers_bytes_sent_ = 0;
   chunked_decoder_.reset();
   // Reset all the members of response_.
   response_ = HttpResponseInfo();
 }
 
 bool HttpNetworkTransaction::ShouldResendRequest() {
   // NOTE: we resend a request only if we reused a keep-alive connection.
   // This automatically prevents an infinite resend loop because we'll run
   // out of the cached keep-alive connections eventually.
   if (establishing_tunnel_ ||
       !reused_socket_ ||  // We didn't reuse a keep-alive connection.
       header_buf_len_) {  // We have received some response headers.
     return false;
   }
   connection_.set_socket(NULL);
   connection_.Reset();
   // There are two reasons we need to clear request_headers_.  1) It contains
   // the real request headers, but we may need to resend the CONNECT request
   // first to recreate the SSL tunnel.  2) An empty request_headers_ causes
   // BuildRequestHeaders to be called, which rewinds request_body_stream_ to
   // the beginning of request_->upload_data.
-  request_headers_.clear();
+  request_headers_->headers_.clear();
   request_headers_bytes_sent_ = 0;
   next_state_ = STATE_INIT_CONNECTION;  // Resend the request.
   return true;
 }
 
 int HttpNetworkTransaction::ReconsiderProxyAfterError(int error) {
   DCHECK(!pac_request_);
 
   // A failure to resolve the hostname or any error related to establishing a
   // TCP connection could be grounds for trying a new proxy configuration.
@@ skipping 43 matching lines @@
     return;
 
   DCHECK(HaveAuth(target));
 
   // Add a Authorization/Proxy-Authorization header line.
   std::string credentials = auth_handler_[target]->GenerateCredentials(
       auth_identity_[target].username,
       auth_identity_[target].password,
       request_,
       &proxy_info_);
-  request_headers_ += HttpAuth::GetAuthorizationHeaderName(target) +
+  request_headers_->headers_ += HttpAuth::GetAuthorizationHeaderName(target) +
       ": "  + credentials + "\r\n";
 }
 
 void HttpNetworkTransaction::ApplyAuth() {
   // We expect using_proxy_ and using_tunnel_ to be mutually exclusive.
   DCHECK(!using_proxy_ || !using_tunnel_);
 
   // Don't send proxy auth after tunnel has been established.
   bool should_apply_proxy_auth = using_proxy_ || establishing_tunnel_;
 
@@ skipping 245 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server().host_and_port());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net