Upstream "nsurl_util.{h,mm}" from Chrome on iOS repository.

net/base/mac/url_conversions.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 "net/base/mac/url_conversions.h"
+
+#import <Foundation/Foundation.h>
+
+#include "base/logging.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/strings/sys_string_conversions.h"
+#include "url/gurl.h"
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+#include "base/mac/mac_util.h"
+#include "base/mac/sdk_forward_declarations.h"
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+#if defined(OS_IOS)
+#include "base/ios/ios_util.h"
+#endif  // defined(OS_IOS)
+
+namespace {
+
+// This function must only be called on OSX 10.7+ or iOS 4+.
+// Returns a valid NSURL (compliant with RFC 1738/1808/2396) from an NSString
+// that can contain any UTF-8 characters, representing a URI.
+// If the input string represents a fully RFC 3986-compliant URI the resulting
+// NSURL will be have the minimum conversion applied to be a valid NSURL with
+// minimum damage to the intention of the RFC 3986-compliant URI.
+// If the string represents a non-standard URI the method will make best-effort
+// to normalize it. Note that making a URI standards-compliant while preserving
+// its intention is *not* an exact science. This is why W3C *require* sites
+// encode their own links as only the site builder knows the true link
+// intention.
+NSURL* URLWithUTF8String(const std::string& string) {
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  DCHECK(base::mac::IsOSLionOrLater());
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+#if defined(OS_IOS)

[droger, 2014/11/21 10:49:39]

You can remove this ifdef, and the include on line 20, because we no longer
support these older OSes.

[erikchen, 2014/12/02 21:19:57]

Done.

+  DCHECK(base::ios::IsRunningOnIOS7OrLater());
+#endif  // defined(OS_IOS)
+
+  // These are all the characters that NSURL *requires* to be encoded
+  // throughout.
+  // NSURL strictly enforces RFC 1738 which says:
+  //   [certain] characters are unsafe because
+  //   gateways and other transport agents are known to sometimes modify
+  //   such characters. These characters are "{", "}", "|", "\", "^", "~",
+  //   "[", "]", and "`".
+  //   All unsafe characters must always be encoded within a URL.
+  // However RFC 3986 relaxes the policy and states:
+  //   characters in the reserved set [which includes these characters]
+  //   are protected from normalization and are therefore safe to be
+  //   used by scheme-specific and producer-specific algorithms for
+  //   delimiting data subcomponents within a URI.
+  // Therefore we *can* expect these characters to appear in URIs but *should*
+  // pct-encode them for RFC 1738.

[mmenke, 2014/11/21 15:48:55]

We do not need a new method to do this.  Set net::EscapePath, and its escape
list: 
https://code.google.com/p/chromium/codesearch#chromium/src/net/base/escape.cc...

Note:  That list does exclude double quotes (") (As does RFC 1738), so if you
need those escaped, you do need to do that yourself.


It also escapes #, which this mentions below.

Actually, though, doesn't GURL itself also escape the same characters as well?

[erikchen, 2014/11/22 00:11:39]

mmenke: What are your expectations? (I ask only so that I reduce the number of
feedback iterations on this CL)

My current best guess is the following:
Some of the logic in this method is very similar to logic in escape.cc. This CL
should not introduce duplicate code - it should reuse the existing code.

1. This code block and the next one (that converts %) is very similar to
EscapePath. I should make a new method in escape.cc
EscapeURLForConversionToNSURL which performs the correct conversion.
2. The following code block is very similar to EscapeNonASCII. I should use
EscapeNonASCII and make a new method called EscapeControlCharacters to replace
this code block.
3. I don't see any equivalent logic for the # replacement, so I should just
leave it as is.

Lastly, I'll need to make sure that nothing funny happens in the std::string ->
NSString conversion, which used to happen at the beginning of this method, but
will now happen near the end of this method.

Let me know if this description accurately matches your expectations.

[mmenke, 2014/11/22 01:04:13]

I'd like to duplicate as little code as possible.

First, I want to know that GURL.spec() does not already have all the escaping
you need.  I'm not currently convinced of this.  It does escaping itself, and we
have to unescape GURLs before we can display them in the omnibox.  Looks like it
also escapes double quotes, so I'm not even convinced this code currently does
anything at all (Other than the # logic).  If we need additional escape logic,
I'd like it in net/escape.h or url/.

If we need to escape extra #'s (1738 isn't clear on this topic - it could just
be referring to the path/query string, since it says all #'s should be escaped,
but that's clearly false.  RFC 3986 is clearer on the subject, though, and seems
to agree with this code), I'd really rather see it done in GURL, rather than
here, if we can manage that.  I'm not a big fan of non-cross-platform URL
handling logic.  Brettw owns that code, and we should run it by him, to see what
he thinks.

Sound reasonable?

+  static NSString* replacements[] = {
+      @" ", @"%20",
+      @"\"", @"%22",
+      @"<", @"%3C",
+      @">", @"%3E",
+      @"[", @"%5B", // NSURL will encode [ itself if we don't
+      @"\\", @"%5C",
+      @"]", @"%5D", // NSURL will encode ] itself if we don't
+      @"^", @"%5E",
+      @"{", @"%7B",
+      @"|", @"%7C",
+      @"}", @"%7D",
+      @"`", @"%60"};
+  int size = arraysize(replacements);
+  base::scoped_nsobject<NSMutableString> newString([[NSMutableString alloc]
+      initWithString:(base::SysUTF8ToNSString(string))]);
+  for (int i = 0; i < size / 2; i++) {
+    [newString replaceOccurrencesOfString:replacements[i * 2]
+                               withString:replacements[i * 2 + 1]
+                                  options:NSLiteralSearch
+                                    range:NSMakeRange(0, [newString length])];
+  }
+  // RFC 1738:
+  //   The character "%" is unsafe because it is used for
+  //   encodings of other characters.
+  //   All unsafe characters must always be encoded within a URL.
+  // Conclusion; % symbols that do not begin valid pct-encoding sequences should
+  // be pct-encoded (converted to %25).
+  // However, % symbols that begin pct-encoded sequences should be left
+  // untouched as these can appear in RFC 3986-compliant URIs.
+  [newString replaceOccurrencesOfString:@"%(?![a-fA-F0-9]{2})"
+                             withString:@"%25"
+                                options:NSRegularExpressionSearch
+                                  range:NSMakeRange(0, [newString length])];
+
+  // RFC 1738:
+  //   URLs are written only with the graphic printable characters of the
+  //   US-ASCII coded character set. The octets 80-FF hexadecimal are not used
+  //   in US-ASCII. [...] the octets 00-1F and 7F hexadecimal represent control
+  //   characters; these must be encoded.
+  NSUInteger length = [newString length];
+  // String is iterated in reverse to allow easy replacement of fragments with
+  // longer strings.
+  for (NSUInteger i = [newString length] - 1; i < length; i--) {
+    unichar uc = [newString characterAtIndex:i];
+    if (uc >= 0x7F || uc < 0x20) {
+      NSString* asString;
+      if (uc == 0x7F || uc < 0x20) {
+        asString = [NSString stringWithFormat:@"%%%02X", uc];
+      } else if (uc <= 0x7ff) {
+        // See row '11 Bits' from http://en.wikipedia.org/wiki/UTF-8#Design
+        asString = [NSString stringWithFormat:@"%%%X%%%X",
+            (6 << 5) | ((uc >> 6) & ((1 << 5) - 1)),
+            (2 << 6) | (uc & ((1 << 6) - 1))];
+      } else {
+        // See row '16 bits' from http://en.wikipedia.org/wiki/UTF-8#Design
+        asString = [NSString stringWithFormat:@"%%%X%%%X%%%X",
+            (14 << 4) | ((uc >> 12) & ((1 << 4) - 1)),
+            (2 << 6) | ((uc >> 6) & ((1 << 6) - 1)),
+            (2 << 6) | (uc & ((1 << 6) - 1))];
+      }
+      [newString replaceCharactersInRange:NSMakeRange(i, 1)
+                               withString:asString];
+    }
+  }
+
+  // RFC 1738:
+  //   The character "#" is unsafe and should
+  //   always be encoded because it is used in World Wide Web and in other
+  //   systems to delimit a URL from a fragment/anchor identifier that might
+  //   follow it.
+  // Conclusion; valid NSURLs can contain one # symbol only. The first # symbol
+  // is likely to be a fragment divider so should be left untouched.
+  NSUInteger firstHash = [newString rangeOfString:@"#"].location;
+  if (firstHash != NSNotFound) {
+    NSUInteger searchLength = [newString length] - (firstHash + 1);
+    if (searchLength > 0) {
+      [newString replaceOccurrencesOfString:@"#"
+                                 withString:@"%23"
+                                    options:NSLiteralSearch
+                                      range:NSMakeRange(firstHash + 1,
+                                          searchLength)];
+    }
+  }
+
+  NSURL* nsUrl = [NSURL URLWithString:newString];
+  // Failure to create a valid NSURL is a program error.
+  DCHECK(nsUrl);
+  return nsUrl;
+}
+
+}  // namespace
+
+namespace net {
+
+NSURL* NSURLWithGURL(const GURL& url) {
+  if (url.is_valid())
+    return URLWithUTF8String(url.spec());
+  return nil;
+}
+
+GURL GURLWithNSURL(NSURL* url) {
+  if (url)
+    return GURL([[url absoluteString] UTF8String]);
+  return GURL();
+}
+
+}  // namespace net