Temporary fix to prevent the DRP from being activated improperly.

chrome/browser/net/pref_proxy_config_tracker_impl_unittest.cc

 // Copyright (c) 2011 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/pref_proxy_config_tracker_impl.h"
 
+#include <string>
+
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "chrome/browser/prefs/pref_service_mock_factory.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/proxy/proxy_config_service_common_unittest.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_list.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using testing::_;
 using testing::Mock;
 
 namespace {
 
 const char kFixedPacUrl[] = "http://chromium.org/fixed_pac_url";
@@ skipping 252 matching lines @@
       ProxyConfigDictionary::CreateSystem());
   loop_.RunUntilIdle();
 
   // Test if we actually use the system setting, which is |kFixedPacUrl|.
   net::ProxyConfig actual_config;
   EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
             proxy_config_service_->GetLatestProxyConfig(&actual_config));
   EXPECT_EQ(GURL(kFixedPacUrl), actual_config.pac_url());
 }
 
+void CheckResolvedProxyMatches(net::ProxyConfig* config,
+                               const GURL& url,
+                               const std::string& result_string) {
+  net::ProxyInfo expected_result;
+  expected_result.UseNamedProxy(result_string);
+
+  net::ProxyInfo result;
+  config->proxy_rules().Apply(url, &result);
+
+  EXPECT_TRUE(expected_result.proxy_list().Equals(result.proxy_list()))
+      << "expected: " << expected_result.proxy_list().ToPacString()
+      << "\nactual: " << result.proxy_list().ToPacString();
+}
+
+TEST_F(PrefProxyConfigTrackerImplTest, ExcludeGooglezipDataReductionProxies) {
+  const std::string kDataReductionProxies =
+      "https://proxy.googlezip.net:443,compress.googlezip.net,"
+      "https://proxy-dev.googlezip.net:443,proxy-dev.googlezip.net,"
+      "quic://proxy.googlezip.net";
+
+  struct {
+    std::string initial_proxy_rules;
+    const char* http_proxy_info;
+    const char* https_proxy_info;
+    const char* ftp_proxy_info;
+  } test_cases[] = {
+      {"http=foopyhttp," + kDataReductionProxies +
+           ",direct://;https=foopyhttps," + kDataReductionProxies +
+           ",direct://;ftp=foopyftp," + kDataReductionProxies + ",direct://",
+       "foopyhttp;direct://",
+       "foopyhttps;direct://",
+       "foopyftp;direct://"},
+
+      {"foopy," + kDataReductionProxies + ",direct://",
+       "foopy;direct://",
+       "foopy;direct://",
+       "foopy;direct://"},
+
+      {"http=" + kDataReductionProxies + ";https=" + kDataReductionProxies +
+           ";ftp=" + kDataReductionProxies,
+       "direct://",
+       "direct://",
+       "direct://"},
+
+      {"http=" + kDataReductionProxies + ",foopy,direct://",
+       "foopy;direct://",
+       "direct://",
+       "direct://"},
+  };
+
+  // Test setting the proxy from a user pref.
+  for (const auto& test : test_cases) {
+    pref_service_->SetUserPref(prefs::kProxy,
+                               ProxyConfigDictionary::CreateFixedServers(
+                                   test.initial_proxy_rules, std::string()));
+    loop_.RunUntilIdle();
+
+    net::ProxyConfig config;
+    EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID,
+              proxy_config_service_->GetLatestProxyConfig(&config));
+
+    CheckResolvedProxyMatches(&config, GURL("http://google.com"),
+                              test.http_proxy_info);
+    CheckResolvedProxyMatches(&config, GURL("https://google.com"),
+                              test.https_proxy_info);
+    CheckResolvedProxyMatches(&config, GURL("ftp://google.com"),
+                              test.ftp_proxy_info);
+  }
+}
+
 // Test parameter object for testing command line proxy configuration.
 struct CommandLineTestParams {
   // Explicit assignment operator, so testing::TestWithParam works with MSVC.
   CommandLineTestParams& operator=(const CommandLineTestParams& other) {
     description = other.description;
     for (unsigned int i = 0; i < arraysize(switches); i++)
       switches[i] = other.switches[i];
     is_null = other.is_null;
     auto_detect = other.auto_detect;
     pac_url = other.pac_url;
@@ skipping 173 matching lines @@
     net::ProxyRulesExpectation::Empty(),
   },
 };
 
 INSTANTIATE_TEST_CASE_P(
     PrefProxyConfigTrackerImplCommandLineTestInstance,
     PrefProxyConfigTrackerImplCommandLineTest,
     testing::ValuesIn(kCommandLineTestParams));
 
 }  // namespace