HttpRequestHeaders refactor.

net/http/http_network_transaction.cc

 // Copyright (c) 2010 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/format_macros.h"
-#include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
+#include "base/format_macros.h"
 #include "base/histogram.h"
+#include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/connection_type_histograms.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_cert_request_info.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_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/socks5_client_socket.h"
 #include "net/socket/socks_client_socket.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket_pool.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
 
 using base::Time;
 
 namespace net {
 
 namespace {
 
 const std::string* g_next_protos = NULL;
 
 void BuildRequestHeaders(const HttpRequestInfo* request_info,
-                         const std::string& authorization_headers,
+                         const HttpRequestHeaders& authorization_headers,
                          const UploadDataStream* upload_data_stream,
                          bool using_proxy,
-                         std::string* request_headers) {
+                         HttpRequestHeaders* request_headers) {
+  const std::string path = using_proxy ?
+      HttpUtil::SpecForRequest(request_info->url) :
+      HttpUtil::PathForRequest(request_info->url);
+  request_headers->SetRequestLine(
+      request_info->method, path, "1.1");
+
+  request_headers->SetHeader(HttpRequestHeaders::kHost,
+                             GetHostAndOptionalPort(request_info->url));
+
+  // For compat with HTTP/1.0 servers and proxies:
+  if (using_proxy) {
+    request_headers->SetHeader(HttpRequestHeaders::kProxyConnection,
+                               "keep-alive");
+  } else {
+    request_headers->SetHeader(HttpRequestHeaders::kConnection, "keep-alive");
+  }
+
+  if (!request_info->user_agent.empty()) {
+    request_headers->SetHeader(HttpRequestHeaders::kUserAgent,
+                               request_info->user_agent);
+  }
+
+  // Our consumer should have made sure that this is a safe referrer.  See for
+  // instance WebCore::FrameLoader::HideReferrer.
+  if (request_info->referrer.is_valid()) {
+    request_headers->SetHeader(HttpRequestHeaders::kReferer,
+                               request_info->referrer.spec());
+  }
+
+  // Add a content length header?
+  if (upload_data_stream) {
+    request_headers->SetHeader(
+        HttpRequestHeaders::kContentLength,
+        Uint64ToString(upload_data_stream->size()));
+  } else if (request_info->method == "POST" || request_info->method == "PUT" ||
+             request_info->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->SetHeader(HttpRequestHeaders::kContentLength, "0");
+  }
+
+  // Honor load flags that impact proxy caches.
+  if (request_info->load_flags & LOAD_BYPASS_CACHE) {
+    request_headers->SetHeader(HttpRequestHeaders::kPragma, "no-cache");
+    request_headers->SetHeader(HttpRequestHeaders::kCacheControl, "no-cache");
+  } else if (request_info->load_flags & LOAD_VALIDATE_CACHE) {
+    request_headers->SetHeader(HttpRequestHeaders::kCacheControl, "max-age=0");
+  }
+
+  request_headers->MergeFrom(authorization_headers);
+
   // Headers that will be stripped from request_info->extra_headers to prevent,
   // e.g., plugins from overriding headers that are controlled using other
   // means. Otherwise a plugin could set a referrer although sending the
   // referrer is inhibited.
   // TODO(jochen): check whether also other headers should be stripped.
   static const char* const kExtraHeadersToBeStripped[] = {
     "Referer"
   };
 
-  const std::string path = using_proxy ?
-      HttpUtil::SpecForRequest(request_info->url) :
-      HttpUtil::PathForRequest(request_info->url);
-  *request_headers =
-      StringPrintf("%s %s HTTP/1.1\r\nHost: %s\r\n",
-                   request_info->method.c_str(), path.c_str(),
-                   GetHostAndOptionalPort(request_info->url).c_str());
+  // TODO(willchan): Change HttpRequestInfo::extra_headers to be a
+  // HttpRequestHeaders.
 
-  // For compat with HTTP/1.0 servers and proxies:
-  if (using_proxy)
-    *request_headers += "Proxy-";
-  *request_headers += "Connection: keep-alive\r\n";
+  std::vector<std::string> extra_headers_vector;
+  Tokenize(request_info->extra_headers, "\r\n", &extra_headers_vector);
+  HttpRequestHeaders extra_headers;
+  if (!extra_headers_vector.empty()) {
+    for (std::vector<std::string>::const_iterator it =
+         extra_headers_vector.begin(); it != extra_headers_vector.end(); ++it)
+      extra_headers.AddHeaderFromString(*it);
 
-  if (!request_info->user_agent.empty()) {
-    StringAppendF(request_headers, "User-Agent: %s\r\n",
-                  request_info->user_agent.c_str());
+    for (size_t i = 0; i < arraysize(kExtraHeadersToBeStripped); ++i)
+      extra_headers.RemoveHeader(kExtraHeadersToBeStripped[i]);
+
+    request_headers->MergeFrom(extra_headers);
   }
-
-  // Our consumer should have made sure that this is a safe referrer.  See for
-  // instance WebCore::FrameLoader::HideReferrer.
-  if (request_info->referrer.is_valid())
-    StringAppendF(request_headers, "Referer: %s\r\n",
-                  request_info->referrer.spec().c_str());
-
-  // Add a content length header?
-  if (upload_data_stream) {
-    StringAppendF(request_headers, "Content-Length: %" PRIu64 "\r\n",
-                  upload_data_stream->size());
-  } else if (request_info->method == "POST" || request_info->method == "PUT" ||
-             request_info->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";
-  }
-
-  // Honor load flags that impact proxy caches.
-  if (request_info->load_flags & LOAD_BYPASS_CACHE) {
-    *request_headers += "Pragma: no-cache\r\nCache-Control: no-cache\r\n";
-  } else if (request_info->load_flags & LOAD_VALIDATE_CACHE) {
-    *request_headers += "Cache-Control: max-age=0\r\n";
-  }
-
-  if (!authorization_headers.empty()) {
-    *request_headers += authorization_headers;
-  }
-
-  // TODO(darin): Need to prune out duplicate headers.
-
-  *request_headers += HttpUtil::StripHeaders(request_info->extra_headers,
-      kExtraHeadersToBeStripped, arraysize(kExtraHeadersToBeStripped));
-  *request_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 BuildTunnelRequest(const HttpRequestInfo* request_info,
-                        const std::string& authorization_headers,
-                        std::string* request_headers) {
+                        const HttpRequestHeaders& authorization_headers,
+                        HttpRequestHeaders* request_headers) {
   // RFC 2616 Section 9 says the Host request-header field MUST accompany all
   // HTTP/1.1 requests.  Add "Proxy-Connection: keep-alive" for compat with
   // HTTP/1.0 proxies such as Squid (required for NTLM authentication).
-  *request_headers = StringPrintf(
-      "CONNECT %s HTTP/1.1\r\nHost: %s\r\nProxy-Connection: keep-alive\r\n",
-      GetHostAndPort(request_info->url).c_str(),
-      GetHostAndOptionalPort(request_info->url).c_str());
+  request_headers->SetRequestLine(
+      "CONNECT", GetHostAndPort(request_info->url), "1.1");
+  request_headers->SetHeader(HttpRequestHeaders::kHost,
+                             GetHostAndOptionalPort(request_info->url));
+  request_headers->SetHeader(HttpRequestHeaders::kProxyConnection,
+                             "keep-alive");
 
-  if (!request_info->user_agent.empty())
-    StringAppendF(request_headers, "User-Agent: %s\r\n",
-                  request_info->user_agent.c_str());
-
-  if (!authorization_headers.empty()) {
-    *request_headers += authorization_headers;
+  if (!request_info->user_agent.empty()) {
+    request_headers->SetHeader(HttpRequestHeaders::kUserAgent,
+                               request_info->user_agent);
   }
 
-  *request_headers += "\r\n";
+  request_headers->MergeFrom(authorization_headers);
 }
 
 void ProcessAlternateProtocol(const HttpResponseHeaders& headers,
                               const HostPortPair& http_host_port_pair,
                               HttpAlternateProtocols* alternate_protocols) {
   if (!g_next_protos || g_next_protos->empty()) {
     // This implies that NPN is not suppoted.  We don't currently support any
     // alternate protocols that don't use NPN.
     return;
   }
@@ skipping 790 matching lines @@
     // headers.
     bool have_proxy_auth =
         ShouldApplyProxyAuth() &&
         (HaveAuth(HttpAuth::AUTH_PROXY) ||
          SelectPreemptiveAuth(HttpAuth::AUTH_PROXY));
     bool have_server_auth =
         ShouldApplyServerAuth() &&
         (HaveAuth(HttpAuth::AUTH_SERVER) ||
          SelectPreemptiveAuth(HttpAuth::AUTH_SERVER));
 
-    std::string authorization_headers;
+    HttpRequestHeaders request_headers;
+    HttpRequestHeaders authorization_headers;
 
     // TODO(wtc): If BuildAuthorizationHeader fails (returns an authorization
     // header with no credentials), we should return an error to prevent
     // entering an infinite auth restart loop.  See http://crbug.com/21050.
     if (have_proxy_auth)
-      authorization_headers.append(
-          BuildAuthorizationHeader(HttpAuth::AUTH_PROXY));
+      AddAuthorizationHeader(HttpAuth::AUTH_PROXY, &authorization_headers);
     if (have_server_auth)
-      authorization_headers.append(
-          BuildAuthorizationHeader(HttpAuth::AUTH_SERVER));
+      AddAuthorizationHeader(HttpAuth::AUTH_SERVER, &authorization_headers);
 
     if (establishing_tunnel_) {
-      BuildTunnelRequest(request_, authorization_headers, &request_headers_);
+      BuildTunnelRequest(request_, authorization_headers, &request_headers);
     } else {
       BuildRequestHeaders(request_, authorization_headers, request_body,
-                          proxy_mode_ == kHTTPProxy, &request_headers_);
+                          proxy_mode_ == kHTTPProxy, &request_headers);
     }
+
+    request_headers_ = request_headers.ToString();
   }
 
   headers_valid_ = false;
   http_stream_.reset(new HttpBasicStream(connection_.get(), load_log_));
 
   return http_stream_->SendRequest(request_, request_headers_,
                                    request_body, &response_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoSendRequestComplete(int result) {
@@ skipping 663 matching lines @@
 
 bool HttpNetworkTransaction::ShouldApplyProxyAuth() const {
   return (proxy_mode_ == kHTTPProxy) || establishing_tunnel_;
 }
 
 bool HttpNetworkTransaction::ShouldApplyServerAuth() const {
   return !establishing_tunnel_ &&
       !(request_->load_flags & LOAD_DO_NOT_SEND_AUTH_DATA);
 }
 
-std::string HttpNetworkTransaction::BuildAuthorizationHeader(
-    HttpAuth::Target target) const {
+void HttpNetworkTransaction::AddAuthorizationHeader(
+    HttpAuth::Target target, HttpRequestHeaders* authorization_headers) const {
   DCHECK(HaveAuth(target));
 
   // Add a Authorization/Proxy-Authorization header line.
   std::string auth_token;
   int rv = auth_handler_[target]->GenerateAuthToken(
       auth_identity_[target].username,
       auth_identity_[target].password,
       request_,
       &proxy_info_,
       &auth_token);
-  if (rv == OK)
-    return HttpAuth::GetAuthorizationHeaderName(target) +
-      ": "  + auth_token + "\r\n";
+  if (rv == OK) {
+    authorization_headers->SetHeader(
+        HttpAuth::GetAuthorizationHeaderName(target), auth_token);
+  }
 
   // TODO(cbentzel): Evict username and password from cache on non-OK return?
   // TODO(cbentzel): Never use this scheme again if
   //                 ERR_UNSUPPORTED_AUTH_SCHEME is returned.
-  return std::string();
 }
 
 GURL HttpNetworkTransaction::AuthOrigin(HttpAuth::Target target) const {
   return target == HttpAuth::AUTH_PROXY ?
       GURL("http://" + proxy_info_.proxy_server().host_and_port()) :
       request_->url.GetOrigin();
 }
 
 std::string HttpNetworkTransaction::AuthPath(HttpAuth::Target target)
     const {
@@ skipping 245 matching lines @@
       http_host_port_pair);
 
   alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
   if (connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 }  // namespace net