Optimize SameDomainOrHost via a fast-fail path

net/base/registry_controlled_domains/registry_controlled_domain.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.
 
 // NB: Modelled after Mozilla's code (originally written by Pamela Greene,
 // later modified by others), but almost entirely rewritten for Chrome.
 //   (netwerk/dns/src/nsEffectiveTLDService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 303 matching lines @@
                       PrivateRegistryFilter filter) {
   // Quickly reject cases where either host is empty.
   if (host1.empty() || host2.empty())
     return false;
 
   // Check for exact host matches, which is faster than looking up the domain
   // and registry.
   if (host1 == host2)
     return true;
 
-  // Check for a domain and registry match.
-  const base::StringPiece& domain1 =
+  const base::StringPiece domain1 =
       GetDomainAndRegistryAsStringPiece(host1, filter);
-  return !domain1.empty() &&
-         (domain1 == GetDomainAndRegistryAsStringPiece(host2, filter));
+
+  // If |domain1| is empty, |host1| either matched no rules in the registry,
+  // or is an IP literal. Since |host2| and |host1| are known to differ,
+  // they can't possibly be same-origin.
+  if (domain1.empty())
+    return false;
+
+  // Fail fast before computing |domain2|, if possible, by checking to see if
+  // |domain1| is a suffix of |host2|. This is a necessary but not sufficient
+  // condition for |domain1| and |domain2| to be equal.
+  if (!base::EndsWith(host2, domain1, base::CompareCase::SENSITIVE))

[Ryan Sleevi, 2017/01/06 00:38:16]

Unclear if you're doing sensitive as an optimization (to force a memcmp vs a
normalization), but the comparison here would be case-insensitive.

However, both |host1| and |host2| should have already been normalized
(punycoded, lowercased, dot stripped) in order to get the domain, so you should
be fine.

+    return false;
+
+  const base::StringPiece domain2 =
+      GetDomainAndRegistryAsStringPiece(host2, filter);
+
+  // We already verified that |domain1| is a suffix of |host2|. And |domain2| is
+  // also a suffix of |host2|, by construction. So if their lengths are equal,
+  // they are identical.
+  return domain2.length() == domain1.length();
 }
 
 }  // namespace
 
 std::string GetDomainAndRegistry(const GURL& gurl,
                                  PrivateRegistryFilter filter) {
   return GetDomainAndRegistryAsStringPiece(gurl.host_piece(), filter)
       .as_string();
 }
 
@@ skipping 96 matching lines @@
 
 void SetFindDomainGraph(const unsigned char* domains, size_t length) {
   CHECK(domains);
   CHECK_NE(length, 0u);
   g_graph = domains;
   g_graph_length = length;
 }
 
 }  // namespace registry_controlled_domains
 }  // namespace net