diff --git a/import.sh b/import.sh
index 5b612f0..010bd70 100644
--- a/import.sh
+++ b/import.sh
@@ -4,7 +4,7 @@
 top=/tmp/chromium
 mkdir $top
 prefix=https://chromium.googlesource.com/chromium/src.git/+archive
-for version in 60.0.3112.101 61.0.3163.100
+for version in 61.0.3163.100 62.0.3202.94
 do
   mkdir $top/$version
   cd $top/$version
diff --git a/src/base/strings/string16.cc b/src/base/strings/string16.cc
index 2139034..a40212f 100644
--- a/src/base/strings/string16.cc
+++ b/src/base/strings/string16.cc
@@ -69,6 +69,7 @@
 }  // namespace base
 }  // namespace url
 
-template class std::basic_string<url::base::char16, url::base::string16_char_traits>;
+template class std::
+    basic_string<url::base::char16, url::base::string16_internals::string16_char_traits>;
 
 #endif  // WCHAR_T_IS_UTF32
diff --git a/src/base/strings/string16.h b/src/base/strings/string16.h
index 67f9cee..b8d6c82 100644
--- a/src/base/strings/string16.h
+++ b/src/base/strings/string16.h
@@ -44,7 +44,6 @@
 
 typedef wchar_t char16;
 typedef std::wstring string16;
-typedef std::char_traits<wchar_t> string16_char_traits;
 
 }  // namespace base
 }  // namespace url
@@ -68,6 +67,11 @@
 BASE_EXPORT char16* c16memcpy(char16* s1, const char16* s2, size_t n);
 BASE_EXPORT char16* c16memset(char16* s, char16 c, size_t n);
 
+// This namespace contains the implementation of base::string16 along with
+// things that need to be found via argument-dependent lookup from a
+// base::string16.
+namespace string16_internals {
+
 struct string16_char_traits {
   typedef char16 char_type;
   typedef int int_type;
@@ -138,7 +142,11 @@
   }
 };
 
-typedef std::basic_string<char16, base::string16_char_traits> string16;
+}  // namespace string16_internals
+
+typedef std::basic_string<char16,
+                          base::string16_internals::string16_char_traits>
+    string16;
 
 }  // namespace base
 }  // namespace url
@@ -182,8 +190,9 @@
 //
 // TODO(mark): File this bug with Apple and update this note with a bug number.
 
-extern template
-class BASE_EXPORT std::basic_string<url::base::char16, url::base::string16_char_traits>;
+extern template class BASE_EXPORT
+    std::basic_string<url::base::char16,
+                      url::base::string16_internals::string16_char_traits>;
 
 // Specialize std::hash for base::string16. Although the style guide forbids
 // this in general, it is necessary for consistency with WCHAR_T_IS_UTF16
diff --git a/src/url/gurl.cc b/src/url/gurl.cc
index f6bf408..e29e397 100644
--- a/src/url/gurl.cc
+++ b/src/url/gurl.cc
@@ -374,6 +374,10 @@
   return other;
 }
 
+GURL GURL::GetWithoutFilename() const {
+  return Resolve(".");
+}
+
 bool GURL::IsStandard() const {
   return url::IsStandard(spec_.data(), parsed_.scheme);
 }
@@ -505,14 +509,14 @@
 
 #endif  // WIN32
 
-bool GURL::DomainIs(url::base::StringPiece lower_ascii_domain) const {
+bool GURL::DomainIs(url::base::StringPiece canonical_domain) const {
   if (!is_valid_)
     return false;
 
   // FileSystem URLs have empty host_piece, so check this first.
-  if (SchemeIsFileSystem() && inner_url_)
-    return inner_url_->DomainIs(lower_ascii_domain);
-  return url::DomainIs(host_piece(), lower_ascii_domain);
+  if (inner_url_ && SchemeIsFileSystem())
+    return inner_url_->DomainIs(canonical_domain);
+  return url::DomainIs(host_piece(), canonical_domain);
 }
 
 bool GURL::EqualsIgnoringRef(const GURL& other) const {
diff --git a/src/url/gurl.h b/src/url/gurl.h
index b3263c8..b410dba 100644
--- a/src/url/gurl.h
+++ b/src/url/gurl.h
@@ -181,6 +181,15 @@
   // will be the empty URL.
   GURL GetWithEmptyPath() const;
 
+  // A helper function to return a GURL without the filename, query values, and
+  // fragment. For example,
+  // GURL("https://www.foo.com/index.html?q=test").GetWithoutFilename().spec()
+  // will return "https://www.foo.com/".
+  // GURL("https://www.foo.com/bar/").GetWithoutFilename().spec()
+  // will return "https://www.foo.com/bar/". If the GURL is invalid or missing a
+  // scheme, authority or path, it will return an empty, invalid GURL.
+  GURL GetWithoutFilename() const;
+
   // A helper function to return a GURL containing just the scheme, host,
   // and port from a URL. Equivalent to clearing any username and password,
   // replacing the path with a slash, and clearing everything after that. If
@@ -388,11 +397,13 @@
   // "www.google.com", this will return true for "com", "google.com", and
   // "www.google.com".
   //
-  // The input domain should be lower-case ASCII to match the canonicalized
-  // scheme. This call is more efficient than getting the host and check
-  // whether host has the specific domain or not because no copies or
-  // object constructions are done.
-  bool DomainIs(url::base::StringPiece lower_ascii_domain) const;
+  // The input domain should match host canonicalization rules. i.e. the input
+  // show be lowercase except for escape chars.
+  //
+  // This call is more efficient than getting the host and checking whether the
+  // host has the specific domain or not because no copies or object
+  // constructions are done.
+  bool DomainIs(url::base::StringPiece canonical_domain) const;
 
   // Checks whether or not two URLs are differing only in the ref (the part
   // after the # character).
diff --git a/src/url/gurl_unittest.cc b/src/url/gurl_unittest.cc
index 510b1ad..f6e426d 100644
--- a/src/url/gurl_unittest.cc
+++ b/src/url/gurl_unittest.cc
@@ -387,6 +387,52 @@
   }
 }
 
+TEST(GURLTest, GetWithoutFilename) {
+  struct TestCase {
+    const char* input;
+    const char* expected;
+  } cases[] = {
+    // Common Standard URLs.
+    {"https://www.google.com",                    "https://www.google.com/"},
+    {"https://www.google.com/",                   "https://www.google.com/"},
+    {"https://www.google.com/maps.htm",           "https://www.google.com/"},
+    {"https://www.google.com/maps/",              "https://www.google.com/maps/"},
+    {"https://www.google.com/index.html",         "https://www.google.com/"},
+    {"https://www.google.com/index.html?q=maps",  "https://www.google.com/"},
+    {"https://www.google.com/index.html#maps/",   "https://www.google.com/"},
+    {"https://foo:bar@www.google.com/maps.htm",   "https://foo:bar@www.google.com/"},
+    {"https://www.google.com/maps/au/index.html", "https://www.google.com/maps/au/"},
+    {"https://www.google.com/maps/au/north",      "https://www.google.com/maps/au/"},
+    {"https://www.google.com/maps/au/north/",     "https://www.google.com/maps/au/north/"},
+    {"https://www.google.com/maps/au/index.html?q=maps#fragment/",     "https://www.google.com/maps/au/"},
+    {"http://www.google.com:8000/maps/au/index.html?q=maps#fragment/", "http://www.google.com:8000/maps/au/"},
+    {"https://www.google.com/maps/au/north/?q=maps#fragment",          "https://www.google.com/maps/au/north/"},
+    {"https://www.google.com/maps/au/north?q=maps#fragment",           "https://www.google.com/maps/au/"},
+    // Less common standard URLs.
+    {"filesystem:http://www.google.com/temporary/bar.html?baz=22", "filesystem:http://www.google.com/temporary/"},
+    {"file:///temporary/bar.html?baz=22","file:///temporary/"},
+    {"ftp://foo/test/index.html",        "ftp://foo/test/"},
+    {"gopher://foo/test/index.html",     "gopher://foo/test/"},
+    {"ws://foo/test/index.html",         "ws://foo/test/"},
+    // Non-standard, hierarchical URLs.
+    {"chrome://foo/bar.html", "chrome://foo/"},
+    {"httpa://foo/test/index.html", "httpa://foo/test/"},
+    // Non-standard, non-hierarchical URLs.
+    {"blob:https://foo.bar/test/index.html", ""},
+    {"about:blank", ""},
+    {"data:foobar", ""},
+    {"scheme:opaque_data", ""},
+    // Invalid URLs.
+    {"foobar", ""},
+  };
+
+  for (size_t i = 0; i < arraysize(cases); i++) {
+    GURL url(cases[i].input);
+    GURL without_filename = url.GetWithoutFilename();
+    EXPECT_EQ(cases[i].expected, without_filename.spec()) << i;
+  }
+}
+
 TEST(GURLTest, Replacements) {
   // The URL canonicalizer replacement test will handle most of these case.
   // The most important thing to do here is to check that the proper
@@ -612,6 +658,11 @@
   GURL invalid_url("google.com");
   EXPECT_FALSE(invalid_url.is_valid());
   EXPECT_FALSE(invalid_url.DomainIs("google.com"));
+
+  GURL url_with_escape_chars("https://www.,.test");
+  EXPECT_TRUE(url_with_escape_chars.is_valid());
+  EXPECT_EQ(url_with_escape_chars.host(), "www.%2C.test");
+  EXPECT_TRUE(url_with_escape_chars.DomainIs("%2C.test"));
 }
 
 TEST(GURLTest, DomainIsTerminatingDotBehavior) {
diff --git a/src/url/origin.cc b/src/url/origin.cc
index 2bf959c..28ea0b6 100644
--- a/src/url/origin.cc
+++ b/src/url/origin.cc
@@ -169,8 +169,8 @@
   return GetPhysicalOrigin().IsSameOriginWith(other.GetPhysicalOrigin());
 }
 
-bool Origin::DomainIs(base::StringPiece lower_ascii_domain) const {
-  return !unique_ && url::DomainIs(tuple_.host(), lower_ascii_domain);
+bool Origin::DomainIs(base::StringPiece canonical_domain) const {
+  return !unique_ && url::DomainIs(tuple_.host(), canonical_domain);
 }
 
 bool Origin::operator<(const Origin& other) const {
diff --git a/src/url/origin.h b/src/url/origin.h
index 9e6b492..8b59b5a 100644
--- a/src/url/origin.h
+++ b/src/url/origin.h
@@ -154,10 +154,14 @@
   // Note: The returned URL will not necessarily be serialized to the same value
   // as the Origin would. The GURL will have an added "/" path for Origins with
   // valid SchemeHostPorts and file Origins.
+  //
+  // Try not to use this method under normal circumstances, as it loses type
+  // information. Downstream consumers can mistake the returned GURL with a full
+  // URL (e.g. with a path component).
   GURL GetURL() const;
 
   // Same as GURL::DomainIs. If |this| origin is unique, then returns false.
-  bool DomainIs(base::StringPiece lower_ascii_domain) const;
+  bool DomainIs(base::StringPiece canonical_domain) const;
 
   // Allows Origin to be used as a key in STL (for example, a std::set or
   // std::map).
diff --git a/src/url/url_canon_etc.cc b/src/url/url_canon_etc.cc
index 31e9fb5..cc74123 100644
--- a/src/url/url_canon_etc.cc
+++ b/src/url/url_canon_etc.cc
@@ -46,6 +46,17 @@
     return input;
   }
 
+  // Skip whitespace removal for `data:` URLs.
+  //
+  // TODO(mkwst): Ideally, this would use something like `base::StartsWith`, but
+  // that turns out to be difficult to do correctly given this function's
+  // character type templating.
+  if (input_len > 5 && input[0] == 'd' && input[1] == 'a' && input[2] == 't' &&
+      input[3] == 'a' && input[4] == ':') {
+    *output_len = input_len;
+    return input;
+  }
+
   // Remove the whitespace into the new buffer and return it.
   for (int i = 0; i < input_len; i++) {
     if (!IsRemovableURLWhitespace(input[i])) {
diff --git a/src/url/url_util.cc b/src/url/url_util.cc
index a390a9d..30f2e7e 100644
--- a/src/url/url_util.cc
+++ b/src/url/url_util.cc
@@ -676,28 +676,27 @@
   return DoFindAndCompareScheme(str, str_len, compare, found_scheme);
 }
 
-bool DomainIs(base::StringPiece canonicalized_host,
-              base::StringPiece lower_ascii_domain) {
-  if (canonicalized_host.empty() || lower_ascii_domain.empty())
+bool DomainIs(base::StringPiece canonical_host,
+              base::StringPiece canonical_domain) {
+  if (canonical_host.empty() || canonical_domain.empty())
     return false;
 
   // If the host name ends with a dot but the input domain doesn't, then we
   // ignore the dot in the host name.
-  size_t host_len = canonicalized_host.length();
-  if (canonicalized_host.back() == '.' && lower_ascii_domain.back() != '.')
+  size_t host_len = canonical_host.length();
+  if (canonical_host.back() == '.' && canonical_domain.back() != '.')
     --host_len;
 
-  if (host_len < lower_ascii_domain.length())
+  if (host_len < canonical_domain.length())
     return false;
 
   // |host_first_pos| is the start of the compared part of the host name, not
   // start of the whole host name.
   const char* host_first_pos =
-      canonicalized_host.data() + host_len - lower_ascii_domain.length();
+      canonical_host.data() + host_len - canonical_domain.length();
 
-  if (!base::LowerCaseEqualsASCII(
-          base::StringPiece(host_first_pos, lower_ascii_domain.length()),
-          lower_ascii_domain)) {
+  if (base::StringPiece(host_first_pos, canonical_domain.length()) !=
+      canonical_domain) {
     return false;
   }
 
@@ -705,7 +704,7 @@
   // if the host name is longer than the input domain name, then the character
   // immediately before the compared part should be a dot. For example,
   // www.google.com has domain "google.com", but www.iamnotgoogle.com does not.
-  if (lower_ascii_domain[0] != '.' && host_len > lower_ascii_domain.length() &&
+  if (canonical_domain[0] != '.' && host_len > canonical_domain.length() &&
       *(host_first_pos - 1) != '.') {
     return false;
   }
diff --git a/src/url/url_util.h b/src/url/url_util.h
index 643c29d..7486bf7 100644
--- a/src/url/url_util.h
+++ b/src/url/url_util.h
@@ -173,16 +173,16 @@
 
 // Hosts  ----------------------------------------------------------------------
 
-// Returns true if the |canonicalized_host| matches or is in the same domain as
-// the given |lower_ascii_domain| string. For example, if the canonicalized
-// hostname is "www.google.com", this will return true for "com", "google.com",
-// and "www.google.com" domains.
+// Returns true if the |canonical_host| matches or is in the same domain as the
+// given |canonical_domain| string. For example, if the canonicalized hostname
+// is "www.google.com", this will return true for "com", "google.com", and
+// "www.google.com" domains.
 //
 // If either of the input StringPieces is empty, the return value is false. The
-// input domain should be a lower-case ASCII string in order to match the
-// canonicalized host.
-URL_EXPORT bool DomainIs(base::StringPiece canonicalized_host,
-                         base::StringPiece lower_ascii_domain);
+// input domain should match host canonicalization rules. i.e. it should be
+// lowercase except for escape chars.
+URL_EXPORT bool DomainIs(base::StringPiece canonical_host,
+                         base::StringPiece canonical_domain);
 
 // Returns true if the hostname is an IP address. Note: this function isn't very
 // cheap, as it must re-parse the host to verify.