Simple fallback implementation.

chrome/browser/net/spdyproxy/data_reduction_proxy_settings.h

 // Copyright 2013 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 CHROME_BROWSER_NET_SPDYPROXY_DATA_REDUCTION_PROXY_SETTINGS_H_
 #define CHROME_BROWSER_NET_SPDYPROXY_DATA_REDUCTION_PROXY_SETTINGS_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_member.h"
 #include "net/base/network_change_notifier.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
 class PrefService;
 
 namespace net {
+class AuthChallengeInfo;
+class HostPortPair;
+class HttpNetworkSession;
 class URLFetcher;
 }
 
 namespace spdyproxy {
 
 // The number of days of bandwidth usage statistics that are tracked.
 const unsigned int kNumDaysInHistory = 60;
 
 // The number of days of bandwidth usage statistics that are presented.
 const unsigned int kNumDaysInHistorySummary = 30;
 
 COMPILE_ASSERT(kNumDaysInHistorySummary <= kNumDaysInHistory,
                DataReductionProxySettings_summary_too_long);
 
 }  // namespace spdyproxy
 
 // Central point for configuring the data reduction proxy.
 // This object lives on the UI thread and all of its methods are expected to
 // be called from there.
 class DataReductionProxySettings
     : public net::URLFetcherDelegate,
       public net::NetworkChangeNotifier::IPAddressObserver {
  public:
   typedef std::vector<long long> ContentLengthList;
+  typedef std::vector<net::HostPortPair> DataReductionProxyList;
 
   DataReductionProxySettings();
   virtual ~DataReductionProxySettings();
 
   void InitDataReductionProxySettings();
 
+  // If proxy authentication is compiled in, pre-cache authentication
+  // keys for all configured proxies in |session|.
+  void InitDataReductionProxySession(net::HttpNetworkSession* session);
+
   // Add a host pattern to bypass. This should follow the same syntax used
   // in net::ProxyBypassRules; that is, a hostname pattern, a hostname suffix
   // pattern, an IP literal, a CIDR block, or the magic string '<local>'.
   // Bypass settings persist for the life of this object and are applied
   // each time the proxy is enabled, but are not updated while it is enabled.
   void AddHostPatternToBypass(const std::string& pattern);
 
   // Add a URL pattern to bypass the proxy. The base implementation strips
   // everything in |pattern| after the first single slash and then treats it
   // as a hostname pattern. Subclasses may implement other semantics.
   virtual void AddURLPatternToBypass(const std::string& pattern);
 
   // Returns true if the data reduction proxy is allowed to be used on this
   // instance of Chrome. 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.
   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.
   bool IsDataReductionProxyPromoAllowed();
 
   // Returns the URL of the data reduction proxy.
   std::string GetDataReductionProxyOrigin();
 
-  // Returns a configuration string for the proxy.
-  std::string GetDataReductionProxyAuth();
+  // Returns the URL of the fallback data reduction proxy.
+  std::string GetDataReductionProxyFallback();
+
+  // Returns a vector of HostPortPairs for all configured proxies.

[bengr, 2013/10/22 17:49:30]

It seems a little strange to return a vector when we have at most a pair.

[marq (ping after 24h), 2013/10/22 21:18:01]

It's somewhat cleaner (to my mind) to write generic code that operates on one or
two objects using a vector than to repeatedly check if there's a second object
or not. I'll see if the pair looks less awkward to me.

+  DataReductionProxyList GetDataReductionProxies();
+
+  // Returns true if |auth_info| represents an authentication challenge from
+  // a compatible, configured proxy.
+  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.
+  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 16 matching lines @@
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
  protected:
   void InitPrefMembers();
   virtual net::URLFetcher* GetURLFetcher();
 
   // Virtualized for unit test support.
   virtual PrefService* GetOriginalProfilePrefs();
   virtual PrefService* GetLocalStatePrefs();
 
-  std::string GetDataReductionProxyOriginHostPort();
-
   bool IsProxyOriginSetOnCommandLine();
   void GetContentLengths(unsigned int days,
                          int64* original_content_length,
                          int64* received_content_length,
                          int64* last_update_time);
   ContentLengthList GetDailyContentLengths(const char* pref_name);
 
   // Sets the proxy configs, enabling or disabling the proxy according to
   // the value of |enabled|. |at_startup| is true when this method is called
   // from InitDataReductionProxySettings.
@@ skipping 11 matching lines @@
 
   bool HasTurnedOn() { return has_turned_on_; }
   bool HasTurnedOff() { return has_turned_off_; }
   // Note that these flags may only be toggled to true, never back to false.
   void SetHasTurnedOn() { has_turned_on_ = true; }
   void SetHasTurnedOff() { has_turned_off_ = true; }
 
   // Accessor for unit tests.
   std::vector<std::string> BypassRules() { return bypass_rules_;}
 
+  // Accessors for default hostnames, virtual for testing.
+  virtual std::string GetDefaultProxyHost();
+  virtual std::string GetDefaultFallbackProxyHost();
+
  private:
   friend class DataReductionProxySettingsTestBase;
   friend class DataReductionProxySettingsTest;
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
+                           TestAuthHashGeneration);
+  FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
+                           TestAuthHashGenerationWithOriginSetViaSwitch);
+  FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestResetDataReductionStatistics);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestIsProxyEnabledOrManaged);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestContentLengths);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestGetDailyContentLengths);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestMaybeActivateDataReductionProxy);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
@@ skipping 15 matching lines @@
   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
+  // the data reduction proxy feature isn't available.
+  base::string16 AuthHashForSalt(int64 salt);
+
   std::vector<std::string> bypass_rules_;
 
   // Indicate whether a user has turned on the data reduction proxy previously
   // in this session.
   bool has_turned_on_;
 
   // Indicate whether a user has turned off the data reduction proxy previously
   // in this session.
   bool has_turned_off_;
 
   bool disabled_by_carrier_;
   bool enabled_by_user_;
 
   scoped_ptr<net::URLFetcher> fetcher_;
   BooleanPrefMember spdy_proxy_auth_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(DataReductionProxySettings);
 };
 
 #endif  // CHROME_BROWSER_NET_SPDYPROXY_DATA_REDUCTION_PROXY_SETTINGS_H_