Revert of Reduce buggy usage of the registry controlled domain service.

components/ssl_errors/error_classification.cc

 // Copyright 2015 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.
 
 #include "components/ssl_errors/error_classification.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 #include <vector>
@@ skipping 55 matching lines @@
                               UNUSED_INTERSTITIAL_CAUSE_ENTRY);
   }
 }
 
 std::vector<HostnameTokens> GetTokenizedDNSNames(
     const std::vector<std::string>& dns_names) {
   std::vector<HostnameTokens> dns_name_tokens;
   for (const auto& dns_name : dns_names) {
     HostnameTokens dns_name_token_single;
     if (dns_name.empty() || dns_name.find('\0') != std::string::npos ||
-        !(HostNameHasKnownTLD(dns_name))) {
+        !(IsHostNameKnownTLD(dns_name))) {
       dns_name_token_single.push_back(std::string());
     } else {
       dns_name_token_single = Tokenize(dns_name);
     }
     dns_name_tokens.push_back(dns_name_token_single);
   }
   return dns_name_tokens;
 }
 
 // If |potential_subdomain| is a subdomain of |parent|, return the number of
@@ skipping 54 matching lines @@
       // Note: not reached when displaying the bad clock interstitial.
       // See |RecordUMAStatisticsForClockInterstitial| below.
       if (cert.HasExpired() &&
           (current_time - cert.valid_expiry()).InDays() < 28) {
         RecordSSLInterstitialCause(overridable, EXPIRED_RECENTLY);
       }
       break;
     }
     case ssl_errors::ErrorInfo::CERT_COMMON_NAME_INVALID: {
       std::string host_name = request_url.host();
-      if (HostNameHasKnownTLD(host_name)) {
+      if (IsHostNameKnownTLD(host_name)) {
         HostnameTokens host_name_tokens = Tokenize(host_name);
         if (IsWWWSubDomainMatch(request_url, cert))
           RecordSSLInterstitialCause(overridable, WWW_SUBDOMAIN_MATCH);
         if (IsSubDomainOutsideWildcard(request_url, cert))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_OUTSIDE_WILDCARD);
         std::vector<std::string> dns_names;
         cert.GetDNSNames(&dns_names);
         std::vector<HostnameTokens> dns_name_tokens =
             GetTokenizedDNSNames(dns_names);
         if (NameUnderAnyNames(host_name_tokens, dns_name_tokens))
@@ skipping 109 matching lines @@
   }
 
   NOTREACHED();
   return CLOCK_STATE_UNKNOWN;
 }
 
 void SetBuildTimeForTesting(const base::Time& testing_time) {
   g_testing_build_time.Get() = testing_time;
 }
 
-bool HostNameHasKnownTLD(const std::string& host_name) {
-  return net::registry_controlled_domains::HostHasRegistryControlledDomain(
+bool IsHostNameKnownTLD(const std::string& host_name) {
+  size_t tld_length = net::registry_controlled_domains::GetRegistryLength(
       host_name, net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
       net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+  if (tld_length == 0 || tld_length == std::string::npos)
+    return false;
+  return true;
 }
 
 HostnameTokens Tokenize(const std::string& name) {
   return base::SplitString(name, ".", base::KEEP_WHITESPACE,
                            base::SPLIT_WANT_ALL);
 }
 
 bool GetWWWSubDomainMatch(const GURL& request_url,
                           const std::vector<std::string>& dns_names,
                           std::string* www_match_host_name) {
   const std::string& host_name = request_url.host();
 
-  if (HostNameHasKnownTLD(host_name)) {
+  if (IsHostNameKnownTLD(host_name)) {
     // Need to account for all possible domains given in the SSL certificate.
     for (const auto& dns_name : dns_names) {
       if (dns_name.empty() || dns_name.find('\0') != std::string::npos ||
           dns_name.length() == host_name.length() ||
-          !HostNameHasKnownTLD(dns_name)) {
+          !IsHostNameKnownTLD(dns_name)) {
         continue;
       } else if (dns_name.length() > host_name.length()) {
         if (url_formatter::StripWWW(base::ASCIIToUTF16(dns_name)) ==
             base::ASCIIToUTF16(host_name)) {
           *www_match_host_name = dns_name;
           return true;
         }
       } else {
         if (url_formatter::StripWWW(base::ASCIIToUTF16(host_name)) ==
             base::ASCIIToUTF16(dns_name)) {
@@ skipping 70 matching lines @@
   HostnameTokens host_name_tokens = Tokenize(host_name);
   std::vector<std::string> dns_names;
   cert.GetDNSNames(&dns_names);
   bool result = false;
 
   // This method requires that the host name be longer than the dns name on
   // the certificate.
   for (const auto& dns_name : dns_names) {
     if (dns_name.length() < 2 || dns_name.length() >= host_name.length() ||
         dns_name.find('\0') != std::string::npos ||
-        !HostNameHasKnownTLD(dns_name) || dns_name[0] != '*' ||
+        !IsHostNameKnownTLD(dns_name) || dns_name[0] != '*' ||
         dns_name[1] != '.') {
       continue;
     }
 
     // Move past the "*.".
     std::string extracted_dns_name = dns_name.substr(2);
     if (FindSubdomainDifference(host_name_tokens,
                                 Tokenize(extracted_dns_name)) == 2) {
       return true;
     }
@@ skipping 72 matching lines @@
   return std::find(dns_names_domain.begin(), dns_names_domain.end() - 1,
                    host_name_domain) != dns_names_domain.end() - 1;
 }
 
 bool IsHostnameNonUniqueOrDotless(const std::string& hostname) {
   return net::IsHostnameNonUnique(hostname) ||
          hostname.find('.') == std::string::npos;
 }
 
 }  // namespace ssl_errors