Use non-static set_key interface on DataReductionProxySettings

components/data_reduction_proxy/browser/data_reduction_proxy_settings.h

 // 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.
 
 #ifndef COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_SETTINGS_H_
 #define COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_SETTINGS_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 83 matching lines @@
 
   // Returns true if the data reduction proxy key is set on the command line.
   static bool IsProxyKeySetOnCommandLine();
 
   // Returns true if this application instance is part of the data reduction
   // proxy field trial, or if it a proxy origin is set in flags. This is a
   // convenience method for platforms like Chrome on Android and iOS, to
   // determine if the data reduction proxy is allowed.
   static bool IsIncludedInFieldTrialOrFlags();
 
-  static void SetKey(const std::string& key);
   static void SetAllowed(bool allowed);
   static void SetPromoAllowed(bool promo_allowed);
 
   DataReductionProxySettings();
   virtual ~DataReductionProxySettings();
 
+  // Set and get the key to be used for data reduction proxy authentication.
+  void set_key(const std::string& key) {
+    key_ = key;
+  }
+
+  const std::string& key() const {
+    return key_;
+  }
+
   // Initializes the data reduction proxy with profile and local state prefs,
   // and a |UrlRequestContextGetter| for canary probes. The caller must ensure
   // that all parameters remain alive for the lifetime of the
   // |DataReductionProxySettings| instance.
   void InitDataReductionProxySettings(
       PrefService* prefs,
       PrefService* local_state_prefs,
       net::URLRequestContextGetter* url_request_context_getter);
 
   // Initializes the data reduction proxy with profile and local state prefs,
   // a |UrlRequestContextGetter| for canary probes, and a proxy configurator.
   // The caller must ensure that all parameters remain alive for the lifetime of
   // the |DataReductionProxySettings| instance.
   // TODO(marq): Remove when iOS supports the new interface above.
   void InitDataReductionProxySettings(
       PrefService* prefs,
       PrefService* local_state_prefs,
       net::URLRequestContextGetter* url_request_context_getter,
       scoped_ptr<DataReductionProxyConfigurator> config);
 
   // Sets the logic the embedder uses to set the networking configuration that
   // causes traffic to be proxied.
   void SetProxyConfigurator(
       scoped_ptr<DataReductionProxyConfigurator> configurator);
 
-  // If proxy authentication is compiled in, pre-cache authentication
-  // keys for all configured proxies in |session|.
-  static void InitDataReductionProxySession(net::HttpNetworkSession* session);
+  // If proxy authentication is compiled in, pre-cache an authentication
+  // |key| for all configured proxies in |session|.
+  static void InitDataReductionProxySession(net::HttpNetworkSession* session,
+                                            const std::string& key);
 
   // Returns true if the data reduction proxy is allowed to be used. This could
   // return false, for example, if this instance is not part of the field trial,
   // or if the proxy name is not configured via gyp.
   static bool IsDataReductionProxyAllowed();
 
   // Returns true if a screen promoting the data reduction proxy is allowed to
   // be shown. Logic that decides when to show the promo should check its
   // availability. This would return false if not part of a separate field
   // trial that governs the use of the promotion.
@@ skipping 12 matching lines @@
   // Returns a vector of GURLs for all configured proxies.
   static DataReductionProxyList GetDataReductionProxies();
 
   // Returns true if |auth_info| represents an authentication challenge from
   // a compatible, configured proxy.
   static bool IsAcceptableAuthChallenge(net::AuthChallengeInfo* auth_info);
 
   // Returns a UTF16 string suitable for use as an authentication token in
   // response to the challenge represented by |auth_info|. If the token can't
   // be correctly generated for |auth_info|, returns an empty UTF16 string.
-  static base::string16 GetTokenForAuthChallenge(
-      net::AuthChallengeInfo* auth_info);
+  base::string16 GetTokenForAuthChallenge(net::AuthChallengeInfo* auth_info);
 
   // Returns true if the proxy is enabled.
   bool IsDataReductionProxyEnabled();
 
   // Returns true if the proxy is managed by an adminstrator's policy.
   bool IsDataReductionProxyManaged();
 
   // Enables or disables the data reduction proxy. If a probe URL is available,
   // and a probe request fails at some point, the proxy won't be used until a
   // probe succeeds.
@@ skipping 96 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestBypassList);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            CheckInitMetricsWhenNotAllowed);
 
   // NetworkChangeNotifier::IPAddressObserver:
   virtual void OnIPAddressChanged() OVERRIDE;
 
   // Underlying implementation of InitDataReductionProxySession(), factored
   // out to be testable without creating a full HttpNetworkSession.
-  static void InitDataReductionAuthentication(net::HttpAuthCache* auth_cache);
+  static void InitDataReductionAuthentication(net::HttpAuthCache* auth_cache,
+                                              const std::string& key);
 
   void OnProxyEnabledPrefChange();
 
   void ResetDataReductionStatistics();
 
   void MaybeActivateDataReductionProxy(bool at_startup);
 
   // Requests the proxy probe URL, if one is set.  If unable to do so, disables
   // the proxy, if enabled. Otherwise enables the proxy if disabled by a probe
   // failure.
   void ProbeWhetherDataReductionProxyIsAvailable();
   std::string GetProxyCheckURL();
 
   // Returns a UTF16 string that's the hash of the configured authentication
-  // key and |salt|. Returns an empty UTF16 string if no key is configured or
+  // |key| and |salt|. Returns an empty UTF16 string if no key is configured or
   // the data reduction proxy feature isn't available.
-  static base::string16 AuthHashForSalt(int64 salt);
+  static base::string16 AuthHashForSalt(int64 salt, const std::string& key);
 
-  static std::string key_;
   static bool allowed_;
   static bool promo_allowed_;
 
+  std::string key_;
   bool restricted_by_carrier_;
   bool enabled_by_user_;
 
   scoped_ptr<net::URLFetcher> fetcher_;
   BooleanPrefMember spdy_proxy_auth_enabled_;
 
   PrefService* prefs_;
   PrefService* local_state_prefs_;
 
   net::URLRequestContextGetter* url_request_context_getter_;
 
   scoped_ptr<DataReductionProxyConfigurator> config_;
 
   base::ThreadChecker thread_checker_;
 
   bool fallback_allowed_;
 
   DISALLOW_COPY_AND_ASSIGN(DataReductionProxySettings);
 };
 
 }  // namespace data_reduction_proxy
 
 #endif  // COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_SETTINGS_H_