Allow CrossSiteDocumentClassifier to operate on Origins

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 86 matching lines @@
       return 0;  // Multiple trailing dots.
   }
 
   // Walk up the domain tree, most specific to least specific,
   // looking for matches at each level.
   size_t prev_start = std::string::npos;
   size_t curr_start = host_check_begin;
   size_t next_dot = host.find('.', curr_start);
   if (next_dot >= host_check_len)  // Catches std::string::npos as well.
     return 0;  // This can't have a registry + domain.
   while (1) {

[ncarter (slow), 2017/01/03 19:38:27]

Totally random thought -- is this function a hot spot?

It seems like this loop could potentially be eliminated by constructing the
DAFSA so that it consumes the string in reverse (i.e. make it a 'find longest
suffix from fixed set' computation), which would not only eliminate this loop,
but probably mean we'd be able to stop after looking at five or six characters
in a lot of cases (for example, as soon as we see the z in baz.com, we know that
'com' is the only match).

[Charlie Harrison, 2017/01/03 22:16:56]

I think I understand what you are saying. Rather than "lookup string in fixed
set" we make the DAFSA interface instead "return longest match". Then, by
seeding the DAFSA backwards, we can just return the longest match using
host.reverse().

If the match lines up with a dot correctly, we can return the length.

This used to be a major hot spot until I recently fixed SameDomainOrHost to
early return when hosts are identical, but it could still be hot in some
circumstances.

     const char* domain_str = host.data() + curr_start;
     size_t domain_length = host_check_len - curr_start;
     int type = LookupStringInFixedSet(g_graph, g_graph_length, domain_str,
                                       domain_length);
     bool do_check = type != kDafsaNotFound &&
                     (!(type & kDafsaPrivateRule) ||
                      private_filter == INCLUDE_PRIVATE_REGISTRIES);
 
     // If the apparent match is a private registry and we're not including
     // those, it can't be an actual match.
@@ skipping 184 matching lines @@
       try_output.Complete();
       if (try_string == canonical_rcd)
         return host.length() - current_try;
     }
   }
 
   NOTREACHED();
   return canonical_rcd_len;
 }
 
+}  // namespace
+
+std::string GetDomainAndRegistry(const GURL& gurl,
+                                 PrivateRegistryFilter filter) {
+  return GetDomainAndRegistryAsStringPiece(gurl.host_piece(), filter)
+      .as_string();
+}
+
+std::string GetDomainAndRegistry(base::StringPiece host,
+                                 PrivateRegistryFilter filter) {
+  url::CanonHostInfo host_info;
+  const std::string canon_host(CanonicalizeHost(host, &host_info));
+  if (canon_host.empty() || host_info.IsIPAddress())
+    return std::string();
+  return GetDomainAndRegistryImpl(canon_host, filter).as_string();
+}
+
 bool SameDomainOrHost(base::StringPiece host1,
                       base::StringPiece host2,
                       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 =
       GetDomainAndRegistryAsStringPiece(host1, filter);
   return !domain1.empty() &&
          (domain1 == GetDomainAndRegistryAsStringPiece(host2, filter));
 }
 
-}  // namespace
-
-std::string GetDomainAndRegistry(const GURL& gurl,
-                                 PrivateRegistryFilter filter) {
-  return GetDomainAndRegistryAsStringPiece(gurl.host_piece(), filter)
-      .as_string();
-}
-
-std::string GetDomainAndRegistry(base::StringPiece host,
-                                 PrivateRegistryFilter filter) {
-  url::CanonHostInfo host_info;
-  const std::string canon_host(CanonicalizeHost(host, &host_info));
-  if (canon_host.empty() || host_info.IsIPAddress())
-    return std::string();
-  return GetDomainAndRegistryImpl(canon_host, filter).as_string();
-}
-
-bool SameDomainOrHost(
-    const GURL& gurl1,
-    const GURL& gurl2,
-    PrivateRegistryFilter filter) {
+bool SameDomainOrHost(const GURL& gurl1,
+                      const GURL& gurl2,
+                      PrivateRegistryFilter filter) {
   return SameDomainOrHost(gurl1.host_piece(), gurl2.host_piece(), filter);
 }
 
 bool SameDomainOrHost(const url::Origin& origin1,
                       const url::Origin& origin2,
                       PrivateRegistryFilter filter) {
   return SameDomainOrHost(origin1.host(), origin2.host(), filter);
 }
 
 bool SameDomainOrHost(const url::Origin& origin1,
@@ skipping 73 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