Use HttpRequestHeaders for extra_headers.

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/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
@@ skipping 33 matching lines @@
 namespace net {
 
 namespace {
 
 const std::string* g_next_protos = NULL;
 
 void BuildRequestHeaders(const HttpRequestInfo* request_info,
                          const HttpRequestHeaders& authorization_headers,
                          const UploadDataStream* upload_data_stream,
                          bool using_proxy,
+                         std::string* request_line,
                          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_line = StringPrintf(
+      "%s %s HTTP/1.1\r\n", request_info->method.c_str(), path.c_str());
   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(
@@ skipping 20 matching lines @@
 
   // 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"
   };
 
-  // TODO(willchan): Change HttpRequestInfo::extra_headers to be a
-  // HttpRequestHeaders.
-
-  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);
-
+  HttpRequestHeaders stripped_extra_headers;
+  stripped_extra_headers.CopyFrom(request_info->extra_headers);
     for (size_t i = 0; i < arraysize(kExtraHeadersToBeStripped); ++i)
-      extra_headers.RemoveHeader(kExtraHeadersToBeStripped[i]);
-
-    request_headers->MergeFrom(extra_headers);
-  }
+      stripped_extra_headers.RemoveHeader(kExtraHeadersToBeStripped[i]);
+  request_headers->MergeFrom(stripped_extra_headers);
 }
 
 // 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 HttpRequestHeaders& authorization_headers,
+                        std::string* request_line,
                         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->SetRequestLine(
-      "CONNECT", GetHostAndPort(request_info->url), "1.1");
+  *request_line = StringPrintf(
+      "CONNECT %s HTTP/1.1\r\n", GetHostAndPort(request_info->url).c_str());
   request_headers->SetHeader(HttpRequestHeaders::kHost,
                              GetHostAndOptionalPort(request_info->url));
   request_headers->SetHeader(HttpRequestHeaders::kProxyConnection,
                              "keep-alive");
 
-  if (!request_info->user_agent.empty()) {
-    request_headers->SetHeader(HttpRequestHeaders::kUserAgent,
-                               request_info->user_agent);
-  }
+  std::string user_agent;
+  if (request_info->extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
+                                            &user_agent))
+    request_headers->SetHeader(HttpRequestHeaders::kUserAgent, user_agent);
 
   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.
@@ skipping 759 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 request_line;
     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)
       AddAuthorizationHeader(HttpAuth::AUTH_PROXY, &authorization_headers);
     if (have_server_auth)
       AddAuthorizationHeader(HttpAuth::AUTH_SERVER, &authorization_headers);
 
     if (establishing_tunnel_) {
-      BuildTunnelRequest(request_, authorization_headers, &request_headers);
+      BuildTunnelRequest(request_, authorization_headers, &request_line,
+                         &request_headers);
     } else {
       BuildRequestHeaders(request_, authorization_headers, request_body,
-                          proxy_mode_ == kHTTPProxy, &request_headers);
+                          proxy_mode_ == kHTTPProxy, &request_line,
+                          &request_headers);
     }
 
-    request_headers_ = request_headers.ToString();
+    request_headers_ = request_line + request_headers.ToString();
   }
 
   headers_valid_ = false;
   http_stream_.reset(new HttpBasicStream(connection_.get(), net_log_));
 
   return http_stream_->SendRequest(request_, request_headers_,
                                    request_body, &response_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoSendRequestComplete(int result) {
@@ skipping 980 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