WORK_IN_PROGRESS: Do effective TLD lookups using a suffix trie

net/base/registry_controlled_domain.cc

 //* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 30 matching lines @@
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 #include "net/base/net_module.h"
 #include "net/base/net_util.h"
 
+#if defined(USE_DOMAIN_SUFFIX_TRIE)
+#include "third_party/domain-registry-provider/src/domain_registry/domain_registry.h"
+#else
 #include "effective_tld_names.cc"
+#endif
 
 namespace net {
 
 namespace {
 
 const int kExceptionRule = 1;
 const int kWildcardRule = 2;
 
 RegistryControlledDomainService* test_instance_;
 
@@ skipping 73 matching lines @@
 
 // static
 RegistryControlledDomainService* RegistryControlledDomainService::GetInstance()
 {
   if (test_instance_)
     return test_instance_;
 
   return Singleton<RegistryControlledDomainService>::get();
 }
 
+#if defined(USE_DOMAIN_SUFFIX_TRIE)
 RegistryControlledDomainService::RegistryControlledDomainService()
-    : find_domain_function_(Perfect_Hash::FindDomain) {
+    : find_domain_function_(NULL) {
+  InitializeDomainRegistry();
 }
+#else
+RegistryControlledDomainService::RegistryControlledDomainService()
+    : find_domain_function_() {
+}
+#endif
 
 // static
 RegistryControlledDomainService* RegistryControlledDomainService::SetInstance(
     RegistryControlledDomainService* instance) {
   RegistryControlledDomainService* old_instance = test_instance_;
   test_instance_ = instance;
   return old_instance;
 }
 
 // static
@@ skipping 24 matching lines @@
 
   // Move past the dot preceding the registry, and search for the next previous
   // dot.  Return the host from after that dot, or the whole host when there is
   // no dot.
   const size_t dot = host.rfind('.', host.length() - registry_length - 2);
   if (dot == std::string::npos)
     return host;
   return host.substr(dot + 1);
 }
 
+#if defined(USE_DOMAIN_SUFFIX_TRIE)
 size_t RegistryControlledDomainService::GetRegistryLengthImpl(
     const std::string& host,
     bool allow_unknown_registries) {
+  DCHECK(!host.empty());
+  if (allow_unknown_registries)
+    return GetRegistryLengthAllowUnknownRegistries(host.c_str());
+  else
+    return ::GetRegistryLength(host.c_str());
+}
+#else
+size_t RegistryControlledDomainService::GetRegistryLengthImpl(
+    const std::string& host,
+    bool allow_unknown_registries) {
   DCHECK(!host.empty());
 
   // Skip leading dots.
   const size_t host_check_begin = host.find_first_not_of('.');
   if (host_check_begin == std::string::npos)
     return 0;  // Host is only dots.
 
   // A single trailing dot isn't relevant in this determination, but does need
   // to be included in the final returned length.
   size_t host_check_len = host.length();
@@ skipping 55 matching lines @@
     prev_start = curr_start;
     curr_start = next_dot + 1;
     next_dot = host.find('.', curr_start);
   }
 
   // No rule found in the registry.  curr_start now points to the first
   // character of the last subcomponent of the host, so if we allow unknown
   // registries, return the length of this subcomponent.
   return allow_unknown_registries ? (host.length() - curr_start) : 0;
 }
+#endif
 
 }  // namespace net