Add support for split Public Suffix List distinctions.

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** 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
@@ skipping 1943 matching lines @@
     CookieMonster::CookieItVector::iterator it_begin,
     CookieMonster::CookieItVector::iterator it_end) {
   for (CookieItVector::iterator it = it_begin; it != it_end; it++) {
     histogram_evicted_last_access_minutes_->Add(
         (current - (*it)->second->LastAccessDate()).InMinutes());
     InternalDeleteCookie((*it), true, cause);
   }
   return it_end - it_begin;
 }
 
-// A wrapper around RegistryControlledDomainService::GetDomainAndRegistry
+// A wrapper around registry_controlled_domains::GetDomainAndRegistry
 // to make clear we're creating a key for our local map.  Here and
 // in FindCookiesForHostAndDomain() are the only two places where
 // we need to conditionalize based on key type.
 //
 // Note that this key algorithm explicitly ignores the scheme.  This is
 // because when we're entering cookies into the map from the backing store,
 // we in general won't have the scheme at that point.
 // In practical terms, this means that file cookies will be stored
 // in the map either by an empty string or by UNC name (and will be
 // limited by kMaxCookiesPerHost), and extension cookies will be stored
 // based on the single extension id, as the extension id won't have the
 // form of a DNS host and hence GetKey() will return it unchanged.
 //
 // Arguably the right thing to do here is to make the key
 // algorithm dependent on the scheme, and make sure that the scheme is
 // available everywhere the key must be obtained (specfically at backing
 // store load time).  This would require either changing the backing store
 // database schema to include the scheme (far more trouble than it's worth), or
 // separating out file cookies into their own CookieMonster instance and
 // thus restricting each scheme to a single cookie monster (which might
 // be worth it, but is still too much trouble to solve what is currently a
 // non-problem).
 std::string CookieMonster::GetKey(const std::string& domain) const {
   std::string effective_domain(
-      RegistryControlledDomainService::GetDomainAndRegistry(domain));
+      registry_controlled_domains::GetDomainAndRegistry(
+          domain, registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES));
   if (effective_domain.empty())
     effective_domain = domain;
 
   if (!effective_domain.empty() && effective_domain[0] == '.')
     return effective_domain.substr(1);
   return effective_domain;
 }
 
 bool CookieMonster::IsCookieableScheme(const std::string& scheme) {
   base::AutoLock autolock(lock_);
@@ skipping 149 matching lines @@
 
 // The system resolution is not high enough, so we can have multiple
 // set cookies that result in the same system time.  When this happens, we
 // increment by one Time unit.  Let's hope computers don't get too fast.
 Time CookieMonster::CurrentTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
 }  // namespace net