Handle disabling data reduction proxy for all platforms.

chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_configurator.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 "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_configurator.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/pref_names.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_params.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
 
 DataReductionProxyChromeConfigurator::DataReductionProxyChromeConfigurator(
     PrefService* prefs,
     scoped_refptr<base::SequencedTaskRunner> network_task_runner)
     : prefs_(prefs), network_task_runner_(network_task_runner) {
 }
 
 DataReductionProxyChromeConfigurator::~DataReductionProxyChromeConfigurator() {
 }
 
+// static
+void DataReductionProxyChromeConfigurator::Disable(PrefService* prefs) {
+  DCHECK(prefs);
+  DictionaryPrefUpdate update(prefs, prefs::kProxy);
+  base::DictionaryValue* dict = update.Get();
+  std::string mode;
+  dict->GetString("mode", &mode);
+  std::string server;
+  dict->GetString("server", &server);
+  if (mode != ProxyModeToString(ProxyPrefs::MODE_FIXED_SERVERS)
+      || !ContainsDataReductionProxy(server))
+    return;

[bengr, 2014/10/28 21:03:41]

I prefer using curly braces when the if clause spans multiple lines.

[Not at Google. Contact bengr, 2014/10/28 22:31:44]

Done.

+
+  dict->SetString("mode", ProxyModeToString(ProxyPrefs::MODE_SYSTEM));
+  dict->SetString("server", "");
+  dict->SetString("bypass_list", "");
+}
+
 void DataReductionProxyChromeConfigurator::Enable(
     bool primary_restricted,
     bool fallback_restricted,
     const std::string& primary_origin,
     const std::string& fallback_origin,
     const std::string& ssl_origin) {
   DCHECK(prefs_);
   DictionaryPrefUpdate update(prefs_, prefs::kProxy);
   // TODO(bengr): Consider relying on the proxy config for all data reduction
   // proxy configuration.
@@ skipping 42 matching lines @@
   config.set_id(unused_id);
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &DataReductionProxyChromeConfigurator::UpdateProxyConfigOnIO,
           base::Unretained(this),
           config));
 }
 
 void DataReductionProxyChromeConfigurator::Disable() {
-  DCHECK(prefs_);
-  DictionaryPrefUpdate update(prefs_, prefs::kProxy);
-  base::DictionaryValue* dict = update.Get();
-  dict->SetString("mode", ProxyModeToString(ProxyPrefs::MODE_SYSTEM));
-  dict->SetString("server", "");
-  dict->SetString("bypass_list", "");
+  Disable(prefs_);
   net::ProxyConfig config = net::ProxyConfig::CreateDirect();
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &DataReductionProxyChromeConfigurator::UpdateProxyConfigOnIO,
           base::Unretained(this),
           config));
 }
 
 void DataReductionProxyChromeConfigurator::AddHostPatternToBypass(
     const std::string& pattern) {
   bypass_rules_.push_back(pattern);
 }
 
 void DataReductionProxyChromeConfigurator::AddURLPatternToBypass(
     const std::string& pattern) {
   size_t pos = pattern.find('/');
   if (pattern.find('/', pos + 1) == pos + 1)
     pos = pattern.find('/', pos + 2);
 
   std::string host_pattern;
   if (pos != std::string::npos)
     host_pattern = pattern.substr(0, pos);
   else
     host_pattern = pattern;
 
   AddHostPatternToBypass(host_pattern);
 }
 
+// static
+bool DataReductionProxyChromeConfigurator::ContainsDataReductionProxy(

[bengr, 2014/10/28 21:03:41]

Why can't you use DRPParams::IsDataReductionProxy?

[Not at Google. Contact bengr, 2014/10/28 22:31:44]

Done.

+    const std::string& server) {
+  data_reduction_proxy::DataReductionProxyParams params(0);
+  return HasProxy(server, params.origin()) ||
+      HasProxy(server, params.fallback_origin()) ||
+      HasProxy(server, params.alt_origin()) ||
+      HasProxy(server, params.ssl_origin());
+}
+
+// static
+bool DataReductionProxyChromeConfigurator::HasProxy(const std::string& server,

[bengr, 2014/10/28 21:03:41]

I don't think you'll need this if you use the method in DRPParams, but if you
do, I'd prefer you work with ProxyServers or HostPortPairs instead of strings.

[Not at Google. Contact bengr, 2014/10/28 22:31:44]

Done.

+                                                    const GURL& proxy) {
+  std::string trimmed_proxy_url;
+  base::TrimString(proxy.spec(), "/", &trimmed_proxy_url);
+  return server.find(trimmed_proxy_url) != std::string::npos;
+}
+
 void DataReductionProxyChromeConfigurator::UpdateProxyConfigOnIO(
     const net::ProxyConfig& config) {
   config_ = config;
 }
 
 const net::ProxyConfig&
 DataReductionProxyChromeConfigurator::GetProxyConfigOnIO() const {
   return config_;
 }