Revert 273810 "Added alternative configuration for the data redu..."

trunk/src/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"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_member.h"
 #include "base/threading/thread_checker.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_configurator.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_params.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 HttpAuthCache;
 class HttpNetworkSession;
@@ skipping 52 matching lines @@
 // 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.
 // TODO(marq): Convert this to be a KeyedService with an
 // associated factory class, and refactor the Java call sites accordingly.
 class DataReductionProxySettings
     : public net::URLFetcherDelegate,
       public net::NetworkChangeNotifier::IPAddressObserver {
  public:
   typedef std::vector<long long> ContentLengthList;
+  // TODO(marq): Consider instead using a std::pair instead of a vector.
+  typedef std::vector<GURL> DataReductionProxyList;
 
+  // Returns true of the data reduction proxy origin is set on the command line.
+  static bool IsProxyOriginSetOnCommandLine();
+
+  // Returns true if the data reduction proxy key is set on the command line.
   static bool IsProxyKeySetOnCommandLine();
 
-  DataReductionProxySettings(DataReductionProxyParams* params);
+  // 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 SetAllowed(bool allowed);
+  static void SetPromoAllowed(bool promo_allowed);
+
+  DataReductionProxySettings();
   virtual ~DataReductionProxySettings();
 
-  DataReductionProxyParams* params() const {
-    return params_.get();
+  // 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> configurator);
+      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,
-      const DataReductionProxyParams* params);
+  // 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.
+  static bool IsDataReductionProxyPromoAllowed();
+
+  // Returns true if preconnect advisory hinting is enabled by command line
+  // flag or Finch trial.
+  static bool IsPreconnectHintingAllowed();
+
+  // Returns the URL of the data reduction proxy.
+  static std::string GetDataReductionProxyOrigin();
+
+  // Returns the URL of the fallback data reduction proxy.
+  static std::string GetDataReductionProxyFallback();
+
+  // 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.
-  bool IsAcceptableAuthChallenge(net::AuthChallengeInfo* auth_info);
+  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.
   base::string16 GetTokenForAuthChallenge(net::AuthChallengeInfo* auth_info);
 
   // Returns true if the proxy is enabled.
   bool IsDataReductionProxyEnabled();
 
-  // Returns true if the alternative proxy is enabled.
-  bool IsDataReductionProxyAlternativeEnabled();
-
   // 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.
   void SetDataReductionProxyEnabled(bool enabled);
 
-  // Enables or disables the alternative data reduction proxy configuration.
-  void SetDataReductionProxyAlternativeEnabled(bool enabled);
+  // If |allowed|, the fallback proxy will be included in the proxy
+  // configuration.
+  void set_fallback_allowed(bool allowed) {
+    fallback_allowed_ = allowed;
+  }
+
+  bool fallback_allowed() const {
+    return fallback_allowed_;
+  }
 
   // Returns the time in microseconds that the last update was made to the
   // daily original and received content lengths.
   int64 GetDataReductionLastUpdateTime();
 
   // Returns a vector containing the total size of all HTTP content that was
   // received over the last |kNumDaysInHistory| before any compression by the
   // data reduction proxy. Each element in the vector contains one day of data.
   ContentLengthList GetDailyOriginalContentLengths();
 
@@ skipping 13 matching lines @@
   virtual PrefService* GetOriginalProfilePrefs();
   virtual PrefService* GetLocalStatePrefs();
 
   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| and |alternative_enabled|. Use the alternative
-  // configuration only if |enabled| and |alternative_enabled| are true. If
-  // |restricted| is true, only enable the fallback proxy. |at_startup| is true
-  // when this method is called from InitDataReductionProxySettings.
-  virtual void SetProxyConfigs(bool enabled,
-                               bool alternative_enabled,
-                               bool restricted,
-                               bool at_startup);
+  // the value of |enabled|. If |restricted| is true, only enable the fallback
+  // proxy. |at_startup| is true when this method is called from
+  // InitDataReductionProxySettings.
+  virtual void SetProxyConfigs(bool enabled, bool restricted, bool at_startup);
 
-  // Metrics method. Subclasses should override if they wish to provide
-  // alternatives.
+  // Metrics methods. Subclasses should override if they wish to provide
+  // alternate methods.
   virtual void RecordDataReductionInit();
 
   virtual void AddDefaultProxyBypassRules();
 
   // Writes a warning to the log that is used in backend processing of
   // customer feedback. Virtual so tests can mock it for verification.
   virtual void LogProxyState(bool enabled, bool restricted, bool at_startup);
 
   // Virtualized for mocking
   virtual void RecordProbeURLFetchResult(
       data_reduction_proxy::ProbeURLFetchResult result);
   virtual void RecordStartupState(
       data_reduction_proxy::ProxyStartupState state);
 
-  DataReductionProxyConfigurator* configurator() {
-    return configurator_.get();
+  DataReductionProxyConfigurator* config() {
+    return config_.get();
   }
 
-  // Reset params for tests.
-  void ResetParamsForTest(DataReductionProxyParams* params);
-
  private:
   friend class DataReductionProxySettingsTestBase;
   friend class DataReductionProxySettingsTest;
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestAuthenticationInit);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestAuthHashGeneration);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestAuthHashGenerationWithOriginSetViaSwitch);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
@@ skipping 11 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestOnProxyEnabledPrefChange);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestInitDataReductionProxyOn);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestInitDataReductionProxyOff);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            TestBypassList);
   FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
                            CheckInitMetricsWhenNotAllowed);
-  FRIEND_TEST_ALL_PREFIXES(DataReductionProxySettingsTest,
-                           TestSetProxyConfigs);
 
   // 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,
-      const DataReductionProxyParams* params);
+  static void InitDataReductionAuthentication(net::HttpAuthCache* auth_cache,
+                                              const std::string& key);
 
   void OnProxyEnabledPrefChange();
-  void OnProxyAlternativeEnabledPrefChange();
 
   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.
-  static base::string16 AuthHashForSalt(int64 salt,
-                                        const std::string& key);
+  static base::string16 AuthHashForSalt(int64 salt, const 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_;
-  BooleanPrefMember data_reduction_proxy_alternative_enabled_;
 
   PrefService* prefs_;
   PrefService* local_state_prefs_;
 
   net::URLRequestContextGetter* url_request_context_getter_;
 
-  scoped_ptr<DataReductionProxyConfigurator> configurator_;
+  scoped_ptr<DataReductionProxyConfigurator> config_;
 
   base::ThreadChecker thread_checker_;
 
-  scoped_ptr<DataReductionProxyParams> params_;
+  bool fallback_allowed_;
 
   DISALLOW_COPY_AND_ASSIGN(DataReductionProxySettings);
 };
 
 }  // namespace data_reduction_proxy
 
 #endif  // COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_SETTINGS_H_