Treat headers and HTTP status text as Latin-1

webkit/child/weburlloader_impl.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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/child/weburlloader_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 53 matching lines @@
     "information.";
 
 class HeaderFlattener : public WebHTTPHeaderVisitor {
  public:
   explicit HeaderFlattener(int load_flags)
       : load_flags_(load_flags),
         has_accept_header_(false) {
   }
 
   virtual void visitHeader(const WebString& name, const WebString& value) {
-    // TODO(darin): is UTF-8 really correct here?  It is if the strings are
-    // already ASCII (i.e., if they are already escaped properly).
-    const std::string& name_utf8 = name.utf8();
-    const std::string& value_utf8 = value.utf8();
+    // Headers are latin1.
+    const std::string& name_latin1 = name.latin1();
+    const std::string& value_latin1 = value.latin1();
 
     // Skip over referrer headers found in the header map because we already
     // pulled it out as a separate parameter.
-    if (LowerCaseEqualsASCII(name_utf8, "referer"))
+    if (LowerCaseEqualsASCII(name_latin1, "referer"))
       return;
 
     // Skip over "Cache-Control: max-age=0" header if the corresponding
     // load flag is already specified. FrameLoader sets both the flag and
     // the extra header -- the extra header is redundant since our network
     // implementation will add the necessary headers based on load flags.
     // See http://code.google.com/p/chromium/issues/detail?id=3434.
     if ((load_flags_ & net::LOAD_VALIDATE_CACHE) &&
-        LowerCaseEqualsASCII(name_utf8, "cache-control") &&
-        LowerCaseEqualsASCII(value_utf8, "max-age=0"))
+        LowerCaseEqualsASCII(name_latin1, "cache-control") &&
+        LowerCaseEqualsASCII(value_latin1, "max-age=0"))
       return;
 
-    if (LowerCaseEqualsASCII(name_utf8, "accept"))
+    if (LowerCaseEqualsASCII(name_latin1, "accept"))
       has_accept_header_ = true;
 
     if (!buffer_.empty())
       buffer_.append("\r\n");
-    buffer_.append(name_utf8 + ": " + value_utf8);
+    buffer_.append(name_latin1 + ": " + value_latin1);
   }
 
   const std::string& GetBuffer() {
     // In some cases, WebKit doesn't add an Accept header, but not having the
     // header confuses some web servers.  See bug 808613.
     if (!has_accept_header_) {
       if (!buffer_.empty())
         buffer_.append("\r\n");
       buffer_.append("Accept: */*");
       has_accept_header_ = true;
@@ skipping 107 matching lines @@
   if (!info.load_timing.receive_headers_end.is_null()) {
     WebURLLoadTiming timing;
     PopulateURLLoadTiming(info.load_timing, &timing);
     response->setLoadTiming(timing);
   }
 
   if (info.devtools_info.get()) {
     WebHTTPLoadInfo load_info;
 
     load_info.setHTTPStatusCode(info.devtools_info->http_status_code);
-    load_info.setHTTPStatusText(WebString::fromUTF8(
+    load_info.setHTTPStatusText(WebString::fromLatin1(
         info.devtools_info->http_status_text));
     load_info.setEncodedDataLength(info.encoded_data_length);
 
-    load_info.setRequestHeadersText(WebString::fromUTF8(
+    load_info.setRequestHeadersText(WebString::fromLatin1(
         info.devtools_info->request_headers_text));
-    load_info.setResponseHeadersText(WebString::fromUTF8(
+    load_info.setResponseHeadersText(WebString::fromLatin1(
         info.devtools_info->response_headers_text));
     const HeadersVector& request_headers = info.devtools_info->request_headers;
     for (HeadersVector::const_iterator it = request_headers.begin();
          it != request_headers.end(); ++it) {
-      load_info.addRequestHeader(WebString::fromUTF8(it->first),
-          WebString::fromUTF8(it->second));
+      load_info.addRequestHeader(WebString::fromLatin1(it->first),
+          WebString::fromLatin1(it->second));
     }
     const HeadersVector& response_headers =
         info.devtools_info->response_headers;
     for (HeadersVector::const_iterator it = response_headers.begin();
          it != response_headers.end(); ++it) {
-      load_info.addResponseHeader(WebString::fromUTF8(it->first),
-          WebString::fromUTF8(it->second));
+      load_info.addResponseHeader(WebString::fromLatin1(it->first),
+          WebString::fromLatin1(it->second));
     }
     response->setHTTPLoadInfo(load_info);
   }
 
   const net::HttpResponseHeaders* headers = info.headers.get();
   if (!headers)
     return;
 
   WebURLResponse::HTTPVersion version = WebURLResponse::Unknown;
   if (headers->GetHttpVersion() == net::HttpVersion(0, 9))
     version = WebURLResponse::HTTP_0_9;
   else if (headers->GetHttpVersion() == net::HttpVersion(1, 0))
     version = WebURLResponse::HTTP_1_0;
   else if (headers->GetHttpVersion() == net::HttpVersion(1, 1))
     version = WebURLResponse::HTTP_1_1;
   response->setHTTPVersion(version);
   response->setHTTPStatusCode(headers->response_code());
-  response->setHTTPStatusText(WebString::fromUTF8(headers->GetStatusText()));
+  response->setHTTPStatusText(WebString::fromLatin1(headers->GetStatusText()));
 
   // TODO(darin): We should leverage HttpResponseHeaders for this, and this
   // should be using the same code as ResourceDispatcherHost.
   // TODO(jungshik): Figure out the actual value of the referrer charset and
   // pass it to GetSuggestedFilename.
   std::string value;
   headers->EnumerateHeader(NULL, "content-disposition", &value);
   response->setSuggestedFileName(
       net::GetSuggestedFilename(url,
                                 value,
                                 std::string(),  // referrer_charset
                                 std::string(),  // suggested_name
                                 std::string(),  // mime_type
                                 std::string()));  // default_name
 
   Time time_val;
   if (headers->GetLastModifiedValue(&time_val))
     response->setLastModifiedDate(time_val.ToDoubleT());
 
   // Build up the header map.
   void* iter = NULL;
   std::string name;
   while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
-    response->addHTTPHeaderField(WebString::fromUTF8(name),
-                                 WebString::fromUTF8(value));
+    response->addHTTPHeaderField(WebString::fromLatin1(name),
+                                 WebString::fromLatin1(value));
   }
 }
 
 net::RequestPriority ConvertWebKitPriorityToNetPriority(
     const WebURLRequest::Priority& priority) {
   switch (priority) {
     case WebURLRequest::PriorityVeryHigh:
       return net::HIGHEST;
 
     case WebURLRequest::PriorityHigh:
@@ skipping 128 matching lines @@
                          &sync_load_response->error_code);
     } else {
       AddRef();  // Balanced in OnCompletedRequest
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&Context::HandleDataURL, this));
     }
     return;
   }
 
   GURL referrer_url(
-      request.httpHeaderField(WebString::fromUTF8("Referer")).utf8());
-  const std::string& method = request.httpMethod().utf8();
+      request.httpHeaderField(WebString::fromUTF8("Referer")).latin1());
+  const std::string& method = request.httpMethod().latin1();
 
   int load_flags = net::LOAD_NORMAL;
   switch (request.cachePolicy()) {
     case WebURLRequest::ReloadIgnoringCacheData:
       // Required by LayoutTests/http/tests/misc/refresh-headers.php
       load_flags |= net::LOAD_VALIDATE_CACHE;
       break;
     case WebURLRequest::ReturnCacheDataElseLoad:
       load_flags |= net::LOAD_PREFERRING_CACHE;
       break;
@@ skipping 395 matching lines @@
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::didChangePriority(WebURLRequest::Priority new_priority) {
   context_->DidChangePriority(new_priority);
 }
 
 }  // namespace webkit_glue