Make SdchManager per-profile.

net/base/sdch_manager.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.
 
 #include "net/base/sdch_manager.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "crypto/sha2.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/url_request/url_request_http_job.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // static
 const size_t SdchManager::kMaxDictionarySize = 1000000;
 
 // static
 const size_t SdchManager::kMaxDictionaryCount = 20;
 
 // static
-SdchManager* SdchManager::global_ = NULL;
-
-// static
 bool SdchManager::g_sdch_enabled_ = true;
 
 // static
 bool SdchManager::g_secure_scheme_supported_ = false;
 
 //------------------------------------------------------------------------------
 SdchManager::Dictionary::Dictionary(const std::string& dictionary_text,
                                     size_t offset,
                                     const std::string& client_hash,
                                     const GURL& gurl,
                                     const std::string& domain,
                                     const std::string& path,
                                     const base::Time& expiration,
                                     const std::set<int>& ports)
     : text_(dictionary_text, offset),
       client_hash_(client_hash),
       url_(gurl),
       domain_(domain),
       path_(path),
       expiration_(expiration),
       ports_(ports) {
 }
 
 SdchManager::Dictionary::~Dictionary() {
 }
 
 bool SdchManager::Dictionary::CanAdvertise(const GURL& target_url) {
-  if (!SdchManager::Global()->IsInSupportedDomain(target_url))
-    return false;
   /* The specific rules of when a dictionary should be advertised in an
      Avail-Dictionary header are modeled after the rules for cookie scoping. The
      terms "domain-match" and "pathmatch" are defined in RFC 2965 [6]. A
      dictionary may be advertised in the Avail-Dictionaries header exactly when
      all of the following are true:
       1. The server's effective host name domain-matches the Domain attribute of
          the dictionary.
       2. If the dictionary has a Port attribute, the request port is one of the
          ports listed in the Port attribute.
       3. The request URI path-matches the path header of the dictionary.
@@ skipping 17 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 // Security functions restricting loads and use of dictionaries.
 
 // static
 bool SdchManager::Dictionary::CanSet(const std::string& domain,
                                      const std::string& path,
                                      const std::set<int>& ports,
                                      const GURL& dictionary_url) {
-  if (!SdchManager::Global()->IsInSupportedDomain(dictionary_url))
-    return false;
   /*
   A dictionary is invalid and must not be stored if any of the following are
   true:
     1. The dictionary has no Domain attribute.
     2. The effective host name that derives from the referer URL host name does
       not domain-match the Domain attribute.
     3. The Domain attribute is a top level domain.
     4. The referer URL host is a host domain name (not IP address) and has the
       form HD, where D is the value of the Domain attribute, and H is a string
       that contains one or more dots.
@@ skipping 36 matching lines @@
   if (!ports.empty()
       && 0 == ports.count(dictionary_url.EffectiveIntPort())) {
     SdchErrorRecovery(DICTIONARY_PORT_NOT_MATCHING_SOURCE_URL);
     return false;
   }
   return true;
 }
 
 // static
 bool SdchManager::Dictionary::CanUse(const GURL& referring_url) {
-  if (!SdchManager::Global()->IsInSupportedDomain(referring_url))
-    return false;
   /*
     1. The request URL's host name domain-matches the Domain attribute of the
       dictionary.
     2. If the dictionary has a Port attribute, the request port is one of the
       ports listed in the Port attribute.
     3. The request URL path-matches the path attribute of the dictionary.
     4. The request is not an HTTPS request.
     We can override (ignore) item (4) only when we have explicitly enabled
     HTTPS support AND dictionary has been acquired over HTTPS.
 */
@@ skipping 49 matching lines @@
 
 // static
 bool SdchManager::Dictionary::DomainMatch(const GURL& gurl,
                                           const std::string& restriction) {
   // TODO(jar): This is not precisely a domain match definition.
   return gurl.DomainIs(restriction.data(), restriction.size());
 }
 
 //------------------------------------------------------------------------------
 SdchManager::SdchManager() {
-  DCHECK(!global_);
   DCHECK(CalledOnValidThread());
-  global_ = this;
 }
 
 SdchManager::~SdchManager() {
-  DCHECK_EQ(this, global_);
   DCHECK(CalledOnValidThread());
   while (!dictionaries_.empty()) {
     DictionaryMap::iterator it = dictionaries_.begin();
     it->second->Release();
     dictionaries_.erase(it->first);
   }
-  global_ = NULL;
 }
 
 // static
-void SdchManager::Shutdown() {
-  EnableSdchSupport(false);
-  if (!global_ )
-    return;
-  global_->set_sdch_fetcher(NULL);
-}
-
-// static
-SdchManager* SdchManager::Global() {
-  return global_;
-}
-
-// static
 void SdchManager::SdchErrorRecovery(ProblemCodes problem) {
   UMA_HISTOGRAM_ENUMERATION("Sdch3.ProblemCodes_4", problem, MAX_PROBLEM_CODE);
 }
 
 void SdchManager::set_sdch_fetcher(SdchFetcher* fetcher) {
   DCHECK(CalledOnValidThread());
   fetcher_.reset(fetcher);
 }
 
 // static
 void SdchManager::EnableSdchSupport(bool enabled) {
   g_sdch_enabled_ = enabled;
 }
 
 // static
 void SdchManager::EnableSecureSchemeSupport(bool enabled) {
   g_secure_scheme_supported_ = enabled;
 }
 
-// static
 void SdchManager::BlacklistDomain(const GURL& url) {
-  if (!global_ )
-    return;
-  global_->SetAllowLatencyExperiment(url, false);
+  SetAllowLatencyExperiment(url, false);
 
   std::string domain(StringToLowerASCII(url.host()));
-  int count = global_->blacklisted_domains_[domain];
+  int count = blacklisted_domains_[domain];
   if (count > 0)
     return;  // Domain is already blacklisted.
 
-  count = 1 + 2 * global_->exponential_blacklist_count[domain];
+  count = 1 + 2 * exponential_blacklist_count[domain];
   if (count > 0)
-    global_->exponential_blacklist_count[domain] = count;
+    exponential_blacklist_count[domain] = count;
   else
     count = INT_MAX;
 
-  global_->blacklisted_domains_[domain] = count;
+  blacklisted_domains_[domain] = count;
 }
 
-// static
 void SdchManager::BlacklistDomainForever(const GURL& url) {
-  if (!global_ )
-    return;
-  global_->SetAllowLatencyExperiment(url, false);
+  SetAllowLatencyExperiment(url, false);
 
   std::string domain(StringToLowerASCII(url.host()));
-  global_->exponential_blacklist_count[domain] = INT_MAX;
-  global_->blacklisted_domains_[domain] = INT_MAX;
+  exponential_blacklist_count[domain] = INT_MAX;
+  blacklisted_domains_[domain] = INT_MAX;
 }
 
-// static
 void SdchManager::ClearBlacklistings() {
-  Global()->blacklisted_domains_.clear();
-  Global()->exponential_blacklist_count.clear();
+  blacklisted_domains_.clear();
+  exponential_blacklist_count.clear();
 }
 
-// static
 void SdchManager::ClearDomainBlacklisting(const std::string& domain) {
-  Global()->blacklisted_domains_.erase(StringToLowerASCII(domain));
+  blacklisted_domains_.erase(StringToLowerASCII(domain));
 }
 
-// static
 int SdchManager::BlackListDomainCount(const std::string& domain) {
-  if (Global()->blacklisted_domains_.end() ==
-      Global()->blacklisted_domains_.find(domain))
+  if (blacklisted_domains_.end() == blacklisted_domains_.find(domain))
     return 0;
-  return Global()->blacklisted_domains_[StringToLowerASCII(domain)];
+  return blacklisted_domains_[StringToLowerASCII(domain)];
 }
 
-// static
 int SdchManager::BlacklistDomainExponential(const std::string& domain) {
-  if (Global()->exponential_blacklist_count.end() ==
-      Global()->exponential_blacklist_count.find(domain))
+  if (exponential_blacklist_count.end() ==
+      exponential_blacklist_count.find(domain))
     return 0;
-  return Global()->exponential_blacklist_count[StringToLowerASCII(domain)];
+  return exponential_blacklist_count[StringToLowerASCII(domain)];
 }
 
 bool SdchManager::IsInSupportedDomain(const GURL& url) {
   DCHECK(CalledOnValidThread());
   if (!g_sdch_enabled_ )
     return false;
 
   if (blacklisted_domains_.empty())
     return true;
 
   std::string domain(StringToLowerASCII(url.host()));
   DomainCounter::iterator it = blacklisted_domains_.find(domain);
   if (blacklisted_domains_.end() == it)
     return true;
 
   int count = it->second - 1;
   if (count > 0)
     blacklisted_domains_[domain] = count;
   else
     blacklisted_domains_.erase(domain);
   SdchErrorRecovery(DOMAIN_BLACKLIST_INCLUDES_TARGET);
   return false;
 }
 
 void SdchManager::FetchDictionary(const GURL& request_url,
                                   const GURL& dictionary_url) {
   DCHECK(CalledOnValidThread());
-  if (SdchManager::Global()->CanFetchDictionary(request_url, dictionary_url) &&
-      fetcher_.get())
+  if (CanFetchDictionary(request_url, dictionary_url) && fetcher_.get())
     fetcher_->Schedule(dictionary_url);
 }
 
 bool SdchManager::CanFetchDictionary(const GURL& referring_url,
                                      const GURL& dictionary_url) const {
   DCHECK(CalledOnValidThread());
   /* The user agent may retrieve a dictionary from the dictionary URL if all of
      the following are true:
        1 The dictionary URL host name matches the referrer URL host name and
            scheme.
@@ skipping 90 matching lines @@
         if (port >= 0)
           ports.insert(port);
       }
     }
 
     if (line_end >= header_end)
       break;
     line_start = line_end + 1;
   }
 
+  if (!IsInSupportedDomain(dictionary_url))
+    return false;
+
   if (!Dictionary::CanSet(domain, path, ports, dictionary_url))
     return false;
 
   // TODO(jar): Remove these hacks to preclude a DOS attack involving piles of
   // useless dictionaries.  We should probably have a cache eviction plan,
   // instead of just blocking additions.  For now, with the spec in flux, it
   // is probably not worth doing eviction handling.
   if (kMaxDictionarySize < dictionary_text.size()) {
     SdchErrorRecovery(DICTIONARY_IS_TOO_LARGE);
     return false;
@@ skipping 16 matching lines @@
 
 void SdchManager::GetVcdiffDictionary(const std::string& server_hash,
     const GURL& referring_url, Dictionary** dictionary) {
   DCHECK(CalledOnValidThread());
   *dictionary = NULL;
   DictionaryMap::iterator it = dictionaries_.find(server_hash);
   if (it == dictionaries_.end()) {
     return;
   }
   Dictionary* matching_dictionary = it->second;
+  if (!IsInSupportedDomain(referring_url))
+    return;
   if (!matching_dictionary->CanUse(referring_url))
     return;
   *dictionary = matching_dictionary;
 }
 
 // TODO(jar): If we have evictions from the dictionaries_, then we need to
 // change this interface to return a list of reference counted Dictionary
 // instances that can be used if/when a server specifies one.
 void SdchManager::GetAvailDictionaryList(const GURL& target_url,
                                          std::string* list) {
   DCHECK(CalledOnValidThread());
   int count = 0;
   for (DictionaryMap::iterator it = dictionaries_.begin();
        it != dictionaries_.end(); ++it) {
+    if (!IsInSupportedDomain(target_url))
+      continue;
     if (!it->second->CanAdvertise(target_url))
       continue;
     ++count;
     if (!list->empty())
       list->append(",");
     list->append(it->second->client_hash());
   }
   // Watch to see if we have corrupt or numerous dictionaries.
   if (count > 0)
     UMA_HISTOGRAM_COUNTS("Sdch3.Advertisement_Count", count);
@@ skipping 50 matching lines @@
       case '/':
         (*output)[i] = '_';
         continue;
       default:
         continue;
     }
   }
 }
 
 }  // namespace net