Remove //net (except for Android test stuff) and sdch

net/proxy/proxy_config_service_common_unittest.cc

Index: net/proxy/proxy_config_service_common_unittest.cc
diff --git a/net/proxy/proxy_config_service_common_unittest.cc b/net/proxy/proxy_config_service_common_unittest.cc
deleted file mode 100644
index 3835bb1ad201f745943395552d625f1c9d033938..0000000000000000000000000000000000000000
--- a/net/proxy/proxy_config_service_common_unittest.cc
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright (c) 2009 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_config_service_common_unittest.h"
-
-#include <string>
-#include <vector>
-
-#include "net/proxy/proxy_config.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace net {
-
-namespace {
-
-// Helper to verify that |expected_proxy| matches the first proxy conatined in
-// |actual_proxies|, and that |actual_proxies| contains exactly one proxy. If
-// either condition is untrue, then |*did_fail| is set to true, and
-// |*failure_details| is filled with a description of the failure.
-void MatchesProxyServerHelper(const char* failure_message,
-                              const char* expected_proxy,
-                              const ProxyList& actual_proxies,
-                              ::testing::AssertionResult* failure_details,
-                              bool* did_fail) {
-  // If |expected_proxy| is empty, then we expect |actual_proxies| to be so as
-  // well.
-  if (strlen(expected_proxy) == 0) {
-    if (!actual_proxies.IsEmpty()) {
-      *did_fail = true;
-      *failure_details
-          << failure_message << ". Was expecting no proxies but got "
-          << actual_proxies.size() << ".";
-    }
-    return;
-  }
-
-  // Otherwise we check that |actual_proxies| holds a single matching proxy.
-  if (actual_proxies.size() != 1) {
-    *did_fail = true;
-    *failure_details
-        << failure_message << ". Was expecting exactly one proxy but got "
-        << actual_proxies.size() << ".";
-    return;
-  }
-
-  ProxyServer actual_proxy = actual_proxies.Get();
-  std::string actual_proxy_string;
-  if (actual_proxy.is_valid())
-    actual_proxy_string = actual_proxy.ToURI();
-
-  if (std::string(expected_proxy) != actual_proxy_string) {
-    *failure_details
-        << failure_message << ". Was expecting: \"" << expected_proxy
-        << "\" but got: \"" << actual_proxy_string << "\"";
-    *did_fail = true;
-  }
-}
-
-std::string FlattenProxyBypass(const ProxyBypassRules& bypass_rules) {
-  std::string flattened_proxy_bypass;
-  for (ProxyBypassRules::RuleList::const_iterator it =
-       bypass_rules.rules().begin();
-       it != bypass_rules.rules().end(); ++it) {
-    if (!flattened_proxy_bypass.empty())
-      flattened_proxy_bypass += ",";
-    flattened_proxy_bypass += (*it)->ToString();
-  }
-  return flattened_proxy_bypass;
-}
-
-}  // namespace
-
-ProxyRulesExpectation::ProxyRulesExpectation(
-    ProxyConfig::ProxyRules::Type type,
-    const char* single_proxy,
-    const char* proxy_for_http,
-    const char* proxy_for_https,
-    const char* proxy_for_ftp,
-    const char* fallback_proxy,
-    const char* flattened_bypass_rules,
-    bool reverse_bypass)
-    : type(type),
-      single_proxy(single_proxy),
-      proxy_for_http(proxy_for_http),
-      proxy_for_https(proxy_for_https),
-      proxy_for_ftp(proxy_for_ftp),
-      fallback_proxy(fallback_proxy),
-      flattened_bypass_rules(flattened_bypass_rules),
-      reverse_bypass(reverse_bypass) {
-}
-
-
-::testing::AssertionResult ProxyRulesExpectation::Matches(
-    const ProxyConfig::ProxyRules& rules) const {
-  ::testing::AssertionResult failure_details = ::testing::AssertionFailure();
-  bool failed = false;
-
-  if (rules.type != type) {
-    failure_details << "Type mismatch. Expected: "
-                    << type << " but was: " << rules.type;
-    failed = true;
-  }
-
-  MatchesProxyServerHelper("Bad single_proxy", single_proxy,
-                           rules.single_proxies, &failure_details, &failed);
-  MatchesProxyServerHelper("Bad proxy_for_http", proxy_for_http,
-                           rules.proxies_for_http, &failure_details,
-                           &failed);
-  MatchesProxyServerHelper("Bad proxy_for_https", proxy_for_https,
-                           rules.proxies_for_https, &failure_details,
-                           &failed);
-  MatchesProxyServerHelper("Bad fallback_proxy", fallback_proxy,
-                           rules.fallback_proxies, &failure_details, &failed);
-
-  std::string actual_flattened_bypass = FlattenProxyBypass(rules.bypass_rules);
-  if (std::string(flattened_bypass_rules) != actual_flattened_bypass) {
-    failure_details
-        << "Bad bypass rules. Expected: \"" << flattened_bypass_rules
-        << "\" but got: \"" << actual_flattened_bypass << "\"";
-    failed = true;
-  }
-
-  if (rules.reverse_bypass != reverse_bypass) {
-    failure_details << "Bad reverse_bypass. Expected: " << reverse_bypass
-                    << " but got: " << rules.reverse_bypass;
-    failed = true;
-  }
-
-  return failed ? failure_details : ::testing::AssertionSuccess();
-}
-
-// static
-ProxyRulesExpectation ProxyRulesExpectation::Empty() {
-  return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_NO_RULES,
-                               "", "", "", "", "", "", false);
-}
-
-// static
-ProxyRulesExpectation ProxyRulesExpectation::EmptyWithBypass(
-    const char* flattened_bypass_rules) {
-  return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_NO_RULES,
-                               "", "", "", "", "", flattened_bypass_rules,
-                               false);
-}
-
-// static
-ProxyRulesExpectation ProxyRulesExpectation::Single(
-    const char* single_proxy,
-    const char* flattened_bypass_rules) {
-  return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY,
-                               single_proxy, "", "", "", "",
-                               flattened_bypass_rules, false);
-}
-
-// static
-ProxyRulesExpectation ProxyRulesExpectation::PerScheme(
-    const char* proxy_http,
-    const char* proxy_https,
-    const char* proxy_ftp,
-    const char* flattened_bypass_rules) {
-  return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
-                               "", proxy_http, proxy_https, proxy_ftp, "",
-                               flattened_bypass_rules, false);
-}
-
-// static
-ProxyRulesExpectation ProxyRulesExpectation::PerSchemeWithSocks(
-    const char* proxy_http,
-    const char* proxy_https,
-    const char* proxy_ftp,
-    const char* socks_proxy,
-    const char* flattened_bypass_rules) {
-  return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
-                               "", proxy_http, proxy_https, proxy_ftp,
-                               socks_proxy, flattened_bypass_rules, false);
-}
-
-// static
-ProxyRulesExpectation ProxyRulesExpectation::PerSchemeWithBypassReversed(
-    const char* proxy_http,
-    const char* proxy_https,
-    const char* proxy_ftp,
-    const char* flattened_bypass_rules) {
-  return ProxyRulesExpectation(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
-                               "", proxy_http, proxy_https, proxy_ftp, "",
-                               flattened_bypass_rules, true);
-}
-
-}  // namespace net