SdchManager: remove EnableSdchSupport

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_macros.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 20 matching lines @@
   GURL::Replacements replacements;
   replacements.SetHostStr(host);
   *gurl = gurl->ReplaceComponents(replacements);
   return;
 }
 
 }  // namespace
 
 namespace net {
 
-// static
-bool SdchManager::g_sdch_enabled_ = true;
-
 SdchManager::DictionarySet::DictionarySet() {}
 
 SdchManager::DictionarySet::~DictionarySet() {}
 
 std::string SdchManager::DictionarySet::GetDictionaryClientHashList() const {
   std::string result;
   bool first = true;
   for (const auto& entry: dictionaries_) {
     if (!first)
       result.append(",");
@@ skipping 42 matching lines @@
   dictionaries_.clear();
   FOR_EACH_OBSERVER(SdchObserver, observers_, OnClearDictionaries());
 }
 
 // static
 void SdchManager::SdchErrorRecovery(SdchProblemCode problem) {
   UMA_HISTOGRAM_ENUMERATION("Sdch3.ProblemCodes_5", problem,
                             SDCH_MAX_PROBLEM_CODE);
 }
 
-// static
-void SdchManager::EnableSdchSupport(bool enabled) {
-  g_sdch_enabled_ = enabled;
-}
-
 void SdchManager::BlacklistDomain(const GURL& url,
                                   SdchProblemCode blacklist_reason) {
   SetAllowLatencyExperiment(url, false);
 
   BlacklistInfo* blacklist_info = &blacklisted_domains_[url.host()];
 
   if (blacklist_info->count > 0)
     return;  // Domain is already blacklisted.
 
   if (blacklist_info->exponential_count > (INT_MAX - 1) / 2) {
@@ skipping 39 matching lines @@
 int SdchManager::BlacklistDomainExponential(const std::string& domain) {
   std::string domain_lower(base::ToLowerASCII(domain));
 
   if (blacklisted_domains_.end() == blacklisted_domains_.find(domain_lower))
     return 0;
   return blacklisted_domains_[domain_lower].exponential_count;
 }
 
 SdchProblemCode SdchManager::IsInSupportedDomain(const GURL& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!g_sdch_enabled_ )
-    return SDCH_DISABLED;

[Randy Smith (Not in Mondays), 2015/08/17 15:39:43]

Should we obsolete this error code in the source enum?  (I.e. comment it out,
but reserve the space, since this almost certainly shows up in UMA, and edit
histograms.xml to match?)

[Elly Fong-Jones, 2015/08/17 17:26:50]

Done.

-
   if (blacklisted_domains_.empty())
     return SDCH_OK;
 
   auto it = blacklisted_domains_.find(url.host());
   if (blacklisted_domains_.end() == it || it->second.count == 0)
     return SDCH_OK;
 
   UMA_HISTOGRAM_ENUMERATION("Sdch3.BlacklistReason", it->second.reason,
                             SDCH_MAX_PROBLEM_CODE);
 
@@ skipping 266 matching lines @@
   // Since this is only done during a dictionary load, and hashes are only 8
   // characters, we just do the simple fixup, rather than rewriting the encoder.
   base::Base64Encode(input, output);
   std::replace(output->begin(), output->end(), '+', '-');
   std::replace(output->begin(), output->end(), '/', '_');
 }
 
 scoped_ptr<base::Value> SdchManager::SdchInfoToValue() const {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 
-  value->SetBoolean("sdch_enabled", sdch_enabled());
+  value->SetBoolean("sdch_enabled", true);
 
   scoped_ptr<base::ListValue> entry_list(new base::ListValue());
   for (const auto& entry: dictionaries_) {
     scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
     entry_dict->SetString("url", entry.second->data.url().spec());
     entry_dict->SetString("client_hash", entry.second->data.client_hash());
     entry_dict->SetString("domain", entry.second->data.domain());
     entry_dict->SetString("path", entry.second->data.path());
     scoped_ptr<base::ListValue> port_list(new base::ListValue());
     for (std::set<int>::const_iterator port_it =
@@ skipping 18 matching lines @@
       entry_dict->SetInteger("tries", it->second.count);
     entry_dict->SetInteger("reason", it->second.reason);
     entry_list->Append(entry_dict.Pass());
   }
   value->Set("blacklisted", entry_list.Pass());
 
   return value.Pass();
 }
 
 }  // namespace net