Handle disabling data reduction proxy for all platforms.

chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_configurator_unittest.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 <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/values.h"
 #include "chrome/common/pref_names.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_params.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class DataReductionProxyConfigTest : public testing::Test {
  public:
   virtual void SetUp() {
     PrefRegistrySimple* registry = pref_service_.registry();
     registry->RegisterDictionaryPref(prefs::kProxy);
     config_.reset(new DataReductionProxyChromeConfigurator(
         &pref_service_,
@@ skipping 13 matching lines @@
     dict->GetString("mode", &mode);
     ASSERT_EQ(expected_mode, mode);
     dict->GetString("server", &server);
     ASSERT_EQ(expected_server, server);
     dict->GetString("bypass_list", &bypass_list);
     ASSERT_EQ(expected_bypass_list, bypass_list);
   }
 
   scoped_ptr<DataReductionProxyChromeConfigurator> config_;
   TestingPrefServiceSimple pref_service_;
+  const int drp_flag =
+      data_reduction_proxy::DataReductionProxyParams::kAllowed |
+      data_reduction_proxy::DataReductionProxyParams::kFallbackAllowed |
+      data_reduction_proxy::DataReductionProxyParams::kAlternativeAllowed |
+      data_reduction_proxy::DataReductionProxyParams::
+          kAlternativeFallbackAllowed;
 };
 
 TEST_F(DataReductionProxyConfigTest, TestUnrestricted) {
   config_->Enable(false,
                   false,
                   "https://www.foo.com:443/",
                   "http://www.bar.com:80/",
                   "");
   CheckProxyConfig(
       "fixed_servers",
@@ skipping 51 matching lines @@
                   true,
                   "https://www.foo.com:443/",
                   "http://www.bar.com:80/",
                   "");
   CheckProxyConfig("fixed_servers",
                    "http=https://www.foo.com:443,direct://;",
                    "");
 }
 
 TEST_F(DataReductionProxyConfigTest, TestBothRestricted) {
+  DictionaryPrefUpdate update(&pref_service_, prefs::kProxy);
+  base::DictionaryValue* dict = update.Get();
+  dict->SetString("mode", "system");
+
   config_->Enable(true,
                   true,
                   "https://www.foo.com:443/",
                   "http://www.bar.com:80/",
                   "");
   CheckProxyConfig("system", "", "");
 }
 
 TEST_F(DataReductionProxyConfigTest, TestDisable) {
+  data_reduction_proxy::DataReductionProxyParams params(drp_flag);
+  config_->Enable(false,
+                  false,
+                  params.origin().spec(),
+                  params.fallback_origin().spec(),
+                  "");
   config_->Disable();
   CheckProxyConfig("system", "", "");
 }
 
+TEST_F(DataReductionProxyConfigTest, TestDisableWithUserOverride) {
+  data_reduction_proxy::DataReductionProxyParams params(drp_flag);
+  config_->Enable(false,
+                  false,
+                  params.origin().spec(),
+                  params.fallback_origin().spec(),
+                  "");
+
+  // Override the data reduction proxy.
+  DictionaryPrefUpdate update(&pref_service_, prefs::kProxy);
+  base::DictionaryValue* dict = update.Get();
+  dict->SetString("server", "https://www.baz.com:22/");
+
+  // This should have no effect since proxy server was overridden.
+  config_->Disable();
+
+  CheckProxyConfig("fixed_servers", "https://www.baz.com:22/", "");
+}
 
 TEST_F(DataReductionProxyConfigTest, TestBypassList) {
   config_->AddHostPatternToBypass("http://www.google.com");
   config_->AddHostPatternToBypass("fefe:13::abc/33");
   config_->AddURLPatternToBypass("foo.org/images/*");
   config_->AddURLPatternToBypass("http://foo.com/*");
   config_->AddURLPatternToBypass("http://baz.com:22/bar/*");
   config_->AddURLPatternToBypass("http://*bat.com/bar/*");
 
   std::string expected[] = {
     "http://www.google.com",
     "fefe:13::abc/33",
     "foo.org",
     "http://foo.com",
     "http://baz.com:22",
     "http://*bat.com"
   };
 
   ASSERT_EQ(config_->bypass_rules_.size(), 6u);
   int i = 0;
   for (std::vector<std::string>::iterator it = config_->bypass_rules_.begin();
        it != config_->bypass_rules_.end(); ++it) {
     EXPECT_EQ(expected[i++], *it);
   }
 }