Use non-static set_key interface on DataReductionProxySettings

components/data_reduction_proxy/browser/data_reduction_proxy_settings.cc

 // Copyright 2014 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/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 49 matching lines @@
     rv = base::StringToInt64(pref_value, &val);
     DCHECK(rv);
   }
   return val;
 }
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
-std::string DataReductionProxySettings::key_;
 bool DataReductionProxySettings::allowed_;
 bool DataReductionProxySettings::promo_allowed_;
 
 // static
 bool DataReductionProxySettings::IsProxyOriginSetOnCommandLine() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   return command_line.HasSwitch(
       data_reduction_proxy::switches::kDataReductionProxy);
 }
 
 // static
 bool DataReductionProxySettings::IsProxyKeySetOnCommandLine() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   return command_line.HasSwitch(
       data_reduction_proxy::switches::kEnableDataReductionProxy);
 }
 
 // static
 bool DataReductionProxySettings::IsIncludedInFieldTrialOrFlags() {
   return (base::FieldTrialList::FindFullName(
               "DataCompressionProxyRollout") == kEnabled ||
           IsProxyOriginSetOnCommandLine());
 }
 
 // static
-void DataReductionProxySettings::SetKey(const std::string& key) {
-  key_ = key;
-}
-
-// static
 void DataReductionProxySettings::SetAllowed(bool allowed) {
   allowed_ = allowed;
 }
 
 // static
 void DataReductionProxySettings::SetPromoAllowed(bool promo_allowed) {
   promo_allowed_ = promo_allowed;
 }
 
 DataReductionProxySettings::DataReductionProxySettings()
-    : restricted_by_carrier_(false),
+    : key_(),
+      restricted_by_carrier_(false),
       enabled_by_user_(false),
       prefs_(NULL),
       local_state_prefs_(NULL),
       url_request_context_getter_(NULL),
       fallback_allowed_(true) {
 }
 
 DataReductionProxySettings::~DataReductionProxySettings() {
   if (IsDataReductionProxyAllowed())
     spdy_proxy_auth_enabled_.Destroy();
 }
 
+void DataReductionProxySettings::set_key(const std::string& key) {
+  key_ = key;
+}
+
+std::string DataReductionProxySettings::key() {
+  return key_;
+}
+
+
 void DataReductionProxySettings::InitPrefMembers() {
   DCHECK(thread_checker_.CalledOnValidThread());
   spdy_proxy_auth_enabled_.Init(
       prefs::kDataReductionProxyEnabled,
       GetOriginalProfilePrefs(),
       base::Bind(&DataReductionProxySettings::OnProxyEnabledPrefChange,
                  base::Unretained(this)));
 }
 
 void DataReductionProxySettings::InitDataReductionProxySettings(
@@ skipping 33 matching lines @@
 }
 
 void DataReductionProxySettings::SetProxyConfigurator(
     scoped_ptr<DataReductionProxyConfigurator> configurator) {
   DCHECK(configurator);
   config_ = configurator.Pass();
 }
 
 // static
 void DataReductionProxySettings::InitDataReductionProxySession(
-    net::HttpNetworkSession* session) {
+    net::HttpNetworkSession* session,
+    const std::string& key) {
 // This is a no-op unless the authentication parameters are compiled in.
 // (even though values for them may be specified on the command line).
 // Authentication will still work if the command line parameters are used,
 // however there will be a round-trip overhead for each challenge/response
 // (typically once per session).
 // TODO(bengr):Pass a configuration struct into DataReductionProxyConfigurator's
 // constructor. The struct would carry everything in the preprocessor flags.
-  if (key_.empty())
+  if (key.empty())
     return;
   DCHECK(session);
   net::HttpAuthCache* auth_cache = session->http_auth_cache();
   DCHECK(auth_cache);
-  InitDataReductionAuthentication(auth_cache);
+  InitDataReductionAuthentication(auth_cache, key);
 }
 
 // static
 void DataReductionProxySettings::InitDataReductionAuthentication(
-    net::HttpAuthCache* auth_cache) {
+    net::HttpAuthCache* auth_cache,
+    const std::string& key) {
   DCHECK(auth_cache);
   int64 timestamp =
       (base::Time::Now() - base::Time::UnixEpoch()).InMilliseconds() / 1000;
 
   DataReductionProxyList proxies = GetDataReductionProxies();
   for (DataReductionProxyList::iterator it = proxies.begin();
       it != proxies.end(); ++it) {
     GURL auth_origin = (*it).GetOrigin();
     int32 rand[3];
     crypto::RandBytes(rand, 3 * sizeof(rand[0]));
 
     std::string realm =
         base::StringPrintf("%s%lld", kAuthenticationRealmName,
                            static_cast<long long>(timestamp));
     std::string challenge = base::StringPrintf(
         "%s realm=\"%s\", ps=\"%lld-%u-%u-%u\"",
         kAuthenticationRealmName,
         realm.data(),
         static_cast<long long>(timestamp),
         rand[0],
         rand[1],
         rand[2]);
-    base::string16 password = AuthHashForSalt(timestamp);
+    base::string16 password = AuthHashForSalt(timestamp, key);
 
     DVLOG(1) << "origin: [" << auth_origin << "] realm: [" << realm
         << "] challenge: [" << challenge << "] password: [" << password << "]";
 
     net::AuthCredentials credentials(base::string16(), password);
     // |HttpAuthController| searches this cache by origin and path, the latter
     // being '/' in the case of the data reduction proxy.
     auth_cache->Add(auth_origin,
                     realm,
                     net::HttpAuth::AUTH_SCHEME_SPDYPROXY,
@@ skipping 74 matching lines @@
   DataReductionProxyList proxies = GetDataReductionProxies();
   for (DataReductionProxyList::iterator it = proxies.begin();
        it != proxies.end(); ++it) {
     net::HostPortPair origin_host = net::HostPortPair::FromURL(*it);
     if (origin_host.Equals(auth_info->challenger))
       return true;
   }
   return false;
 }
 
-// static
 base::string16 DataReductionProxySettings::GetTokenForAuthChallenge(
     net::AuthChallengeInfo* auth_info) {
   if (auth_info->realm.length() > strlen(kAuthenticationRealmName)) {
     int64 salt;
     std::string realm_suffix =
         auth_info->realm.substr(strlen(kAuthenticationRealmName));
     if (base::StringToInt64(realm_suffix, &salt)) {
-      return AuthHashForSalt(salt);
+      return AuthHashForSalt(salt, key_);
     } else {
       DVLOG(1) << "Unable to parse realm name " << auth_info->realm
                << "into an int for salting.";
       return base::string16();
     }
   } else {
     return base::string16();
   }
 }
 
@@ skipping 313 matching lines @@
         switches::kDataReductionProxyProbeURL);
   }
 #if defined(DATA_REDUCTION_PROXY_PROBE_URL)
   return DATA_REDUCTION_PROXY_PROBE_URL;
 #else
   return std::string();
 #endif
 }
 
 // static
-base::string16 DataReductionProxySettings::AuthHashForSalt(int64 salt) {
-  if (!IsDataReductionProxyAllowed())
-    return base::string16();
-
-  std::string key;
+base::string16 DataReductionProxySettings::AuthHashForSalt(
+    int64 salt,
+    const std::string& key) {
+  std::string active_key;
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDataReductionProxy)) {
     // If an origin is provided via a switch, then only consider the value
     // that is provided by a switch. Do not use the preprocessor constant.
     // Don't expose |key_| to a proxy passed in via the command line.
     if (!command_line.HasSwitch(switches::kDataReductionProxyKey))
       return base::string16();
-    key = command_line.GetSwitchValueASCII(switches::kDataReductionProxyKey);
+    active_key = command_line.GetSwitchValueASCII(
+        switches::kDataReductionProxyKey);
   } else {
-    key = key_;
+    active_key = key;
   }
-
-  DCHECK(!key.empty());
+  DCHECK(!active_key.empty());
 
   std::string salted_key =
       base::StringPrintf("%lld%s%lld",
                          static_cast<long long>(salt),
-                         key.c_str(),
+                         active_key.c_str(),
                          static_cast<long long>(salt));
   return base::UTF8ToUTF16(base::MD5String(salted_key));
 }
 
 net::URLFetcher* DataReductionProxySettings::GetURLFetcher() {
   DCHECK(url_request_context_getter_);
   std::string url = GetProxyCheckURL();
   if (url.empty())
     return NULL;
   net::URLFetcher* fetcher = net::URLFetcher::Create(GURL(url),
                                                      net::URLFetcher::GET,
                                                      this);
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE | net::LOAD_BYPASS_PROXY);
   fetcher->SetRequestContext(url_request_context_getter_);
   // Configure max retries to be at most kMaxRetries times for 5xx errors.
   static const int kMaxRetries = 5;
   fetcher->SetMaxRetriesOn5xx(kMaxRetries);
   return fetcher;
 }
 
 void DataReductionProxySettings::ProbeWhetherDataReductionProxyIsAvailable() {
   net::URLFetcher* fetcher = GetURLFetcher();
   if (!fetcher)
     return;
   fetcher_.reset(fetcher);
   fetcher_->Start();
 }
 
 }  // namespace data_reduction_proxy