Temporary fix to prevent the DRP from being activated improperly.

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2012 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 "net/proxy/proxy_service.h"
 
+#include <string>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 215 matching lines @@
   int proxy_fallback_net_error() const {
     return proxy_fallback_net_error_;
   }
 
  private:
   bool on_proxy_fallback_called_;
   ProxyServer proxy_server_;
   int proxy_fallback_net_error_;
 };
 
+void CheckResolvedProxyMatches(ProxyService* service,
+                               const GURL& url,
+                               const std::string& result_string) {
+  ProxyInfo expected_result;
+  expected_result.UseNamedProxy(result_string);
+
+  ProxyInfo result;
+  BoundTestNetLog log;
+  EXPECT_TRUE(service->TryResolveProxySynchronously(url, LOAD_NORMAL, &result,
+                                                    nullptr, log.bound()));
+
+  EXPECT_TRUE(expected_result.proxy_list().Equals(result.proxy_list()))
+      << "expected: " << expected_result.proxy_list().ToPacString()
+      << "\nactual: " << result.proxy_list().ToPacString();
+}
+
 }  // namespace
 
 TEST_F(ProxyServiceTest, Direct) {
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(false);
   ProxyService service(new MockProxyConfigService(ProxyConfig::CreateDirect()),
                        make_scoped_ptr(factory), NULL);
 
   GURL url("http://www.google.com/");
 
@@ skipping 2987 matching lines @@
   bool synchronous_success = service.TryResolveProxySynchronously(
       url, LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_TRUE(synchronous_success);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1", info.proxy_server().host_port_pair().host());
 
   // No request should have been queued.
   EXPECT_EQ(0u, factory->pending_requests().size());
 }
 
+TEST_F(ProxyServiceTest, ExcludeGooglezipDataReductionProxiesFromRules) {
+  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://"},
+  };
+
+  for (const auto& test : test_cases) {
+    scoped_ptr<ProxyService> service(
+        ProxyService::CreateFixed(test.initial_proxy_rules));
+
+    CheckResolvedProxyMatches(service.get(), GURL("http://google.com"),
+                              test.http_proxy_info);
+    CheckResolvedProxyMatches(service.get(), GURL("https://google.com"),
+                              test.https_proxy_info);
+    CheckResolvedProxyMatches(service.get(), GURL("ftp://google.com"),
+                              test.ftp_proxy_info);
+  }
+}
+
 }  // namespace net