[iOS] Upstream //ios/net

ios/net/protocol_handler_util.mm

+// Copyright 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.
+
+#import "ios/net/protocol_handler_util.h"
+
+#include <string>
+
+#include "base/base64.h"
+#include "base/i18n/icu_encoding_detection.h"
+#include "base/i18n/icu_string_conversions.h"
+#include "base/logging.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/macros.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/time/time.h"
+#include "ios/net/crn_http_url_response.h"
+#import "net/base/mac/url_conversions.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_version.h"
+#include "net/url_request/url_request.h"
+#include "url/gurl.h"
+
+namespace {
+
+// "Content-Type" HTTP header.
+NSString* const kContentType = @"Content-Type";
+
+}  // namespace
+
+namespace net {
+
+NSError* GetIOSError(NSInteger ns_error_code,
+                     int net_error_code,
+                     NSString* url,
+                     const base::Time& creation_time) {
+  // The error we pass through has the domain NSURLErrorDomain, an IOS error
+  // code, and a userInfo dictionary in which we smuggle more detailed info
+  // about the error from our network stack. This dictionary contains the
+  // failing URL, and a nested error in which we deposit the original error code
+  // passed in from the Chrome network stack.
+  // The nested error has domain:kErrorDomain, code:|original_error_code|, and
+  // userInfo:nil; this NSError is keyed in the dictionary with
+  // NSUnderlyingErrorKey.
+  NSDate* creation_date = [NSDate
+      dateWithTimeIntervalSinceReferenceDate:creation_time.ToCFAbsoluteTime()];
+  DCHECK(creation_date);
+  NSError* underlying_error =
+      [NSError errorWithDomain:base::SysUTF8ToNSString(kErrorDomain)
+                          code:net_error_code
+                      userInfo:nil];
+  DCHECK(url);
+  NSDictionary* dictionary = @{
+      NSURLErrorFailingURLStringErrorKey : url,
+      @"CreationDate" : creation_date,
+      NSUnderlyingErrorKey : underlying_error,
+  };
+  return [NSError errorWithDomain:NSURLErrorDomain
+                             code:ns_error_code
+                         userInfo:dictionary];
+}
+
+NSURLResponse* GetNSURLResponseForRequest(URLRequest* request) {
+  NSURL* url = NSURLWithGURL(request->url());
+  DCHECK(url);
+
+  // The default iOS stack returns a NSURLResponse when the request has a data
+  // scheme, and a NSHTTPURLResponse otherwise.
+  if (request->url().SchemeIs("data")) {
+    std::string mt;
+    request->GetMimeType(&mt);
+    NSString* mime_type = base::SysUTF8ToNSString(mt);
+    DCHECK(mime_type);
+    std::string cs;
+    request->GetCharset(&cs);
+    NSString* charset = base::SysUTF8ToNSString(cs);
+    DCHECK(charset);
+    // The default iOS stack computes the length of the decoded string. If we
+    // wanted to do that we would have to decode the string now. However, using
+    // the unknown length (-1) seems to be working.
+    return [[[NSURLResponse alloc] initWithURL:url
+                                      MIMEType:mime_type
+                         expectedContentLength:-1
+                              textEncodingName:charset] autorelease];
+  } else {
+    // Iterate over all the headers and copy them.
+    bool has_content_type_header = false;
+    NSMutableDictionary* header_fields = [NSMutableDictionary dictionary];
+    HttpResponseHeaders* headers = request->response_headers();
+    if (headers != nullptr) {
+      void* iter = nullptr;
+      std::string name, value;
+      while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
+        NSString* key = base::SysUTF8ToNSString(name);
+        if (!key) {
+          DLOG(ERROR) << "Header name is not in UTF8: " << name;
+          // Skip the invalid header.
+          continue;
+        }
+        // Do not copy "Cache-Control" headers as we provide our own controls.
+        if ([key caseInsensitiveCompare:@"cache-control"] == NSOrderedSame)
+          continue;
+        if ([key caseInsensitiveCompare:kContentType] == NSOrderedSame) {
+          key = kContentType;
+          has_content_type_header = true;
+        }
+
+        // Handle bad encoding.
+        NSString* v = base::SysUTF8ToNSString(value);
+        if (!v) {
+          DLOG(ERROR) << "Header \"" << name << "\" is not in UTF8: " << value;
+          // Infer the encoding, or skip the header if it's not possible.
+          std::string encoding;
+          if (!base::DetectEncoding(value, &encoding))
+            continue;
+          std::string value_utf8;
+          if (!base::ConvertToUtf8AndNormalize(value, encoding, &value_utf8))
+            continue;
+          v = base::SysUTF8ToNSString(value_utf8);
+          DCHECK(v);
+        }
+
+        // Duplicate keys are appended using a comma separator (RFC 2616).
+        NSMutableString* existing = [header_fields objectForKey:key];
+        if (existing) {
+          [existing appendFormat:@",%@", v];
+        } else {
+          [header_fields setObject:[NSMutableString stringWithString:v]
+                            forKey:key];
+        }
+      }
+    }
+
+    // WebUI does not define a "Content-Type" header. Use the MIME type instead.
+    if (!has_content_type_header) {
+      std::string mime_type = "";
+      request->GetMimeType(&mime_type);
+      NSString* type = base::SysUTF8ToNSString(mime_type);
+      if ([type length])
+        [header_fields setObject:type forKey:kContentType];
+    }
+    NSString* content_type = [header_fields objectForKey:kContentType];
+    if (content_type) {
+      NSRange range = [content_type rangeOfString:@","];
+      // If there are several "Content-Type" headers, keep only the first one.
+      if (range.location != NSNotFound) {
+        [header_fields setObject:[content_type substringToIndex:range.location]
+                          forKey:kContentType];
+      }
+    }
+
+    // Use a "no-store" cache control to ensure that the response is not cached
+    // by the system. See b/7045043.
+    [header_fields setObject:@"no-store" forKey:@"Cache-Control"];
+
+    // Parse the HTTP version.
+    NSString* version_string = @"HTTP/1.1";
+    if (headers) {
+      const HttpVersion& http_version = headers->GetHttpVersion();
+      version_string = [NSString stringWithFormat:@"HTTP/%hu.%hu",
+                                                  http_version.major_value(),
+                                                  http_version.minor_value()];
+    }
+
+    return [[[CRNHTTPURLResponse alloc] initWithURL:url
+                                         statusCode:request->GetResponseCode()
+                                        HTTPVersion:version_string
+                                       headerFields:header_fields] autorelease];
+  }
+}
+
+void CopyHttpHeaders(NSURLRequest* in_request, URLRequest* out_request) {
+  DCHECK(out_request->extra_request_headers().IsEmpty());
+  NSDictionary* headers = [in_request allHTTPHeaderFields];
+  HttpRequestHeaders net_headers;
+  NSString* key;
+  for (key in headers) {
+    if ([key isEqualToString:@"Referer"]) {
+      // The referrer must be set through the set_referrer method rather than as
+      // a header.
+      out_request->SetReferrer(
+          base::SysNSStringToUTF8([headers objectForKey:key]));
+      // If the referrer is explicitly set, we don't want the network stack to
+      // strip it.
+      out_request->set_referrer_policy(URLRequest::NEVER_CLEAR_REFERRER);
+      continue;
+    }
+    if (![key isEqualToString:@"User-Agent"]) {
+      // The user agent string is added by the network stack, and might be
+      // different from the one provided by UIWebView. Do not copy it.
+      NSString* value = [headers objectForKey:key];
+      net_headers.SetHeader(base::SysNSStringToUTF8(key),
+                            base::SysNSStringToUTF8(value));
+    }
+  }
+  // Set default values for some missing headers.
+  // The "Accept" header is defined by Webkit on the desktop version.
+  net_headers.SetHeaderIfMissing("Accept", "*/*");
+  // The custom NSURLProtocol example from Apple adds a default "Content-Type"
+  // header for non-empty POST requests. This suggests that this header can be
+  // missing, and Chrome network stack does not add it by itself.
+  if (out_request->has_upload() && out_request->method() == "POST") {
+    DLOG_IF(WARNING, !net_headers.HasHeader(HttpRequestHeaders::kContentType))
+        << "Missing \"Content-Type\" header in POST request.";
+    net_headers.SetHeaderIfMissing(HttpRequestHeaders::kContentType,
+                                   "application/x-www-form-urlencoded");
+  }
+  out_request->SetExtraRequestHeaders(net_headers);
+}
+
+}  // namespace net