Change ProxyRules to handle ProxyLists rather than just single ProxyServer instances.

net/proxy/proxy_config_service_common_unittest.cc

 // 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 |actual_proxy|. If it does
-// not, then |*did_fail| is set to true, and |*failure_details| is filled with
-// a description of the failure.
+// 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 ProxyServer& actual_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;
   }
@@ skipping 38 matching lines @@
   ::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_proxy, &failure_details, &failed);
+                           rules.single_proxies, &failure_details, &failed);
   MatchesProxyServerHelper("Bad proxy_for_http", proxy_for_http,
-                           rules.proxy_for_http, &failure_details, &failed);
+                           rules.proxies_for_http, &failure_details,
+                           &failed);
   MatchesProxyServerHelper("Bad proxy_for_https", proxy_for_https,
-                           rules.proxy_for_https, &failure_details, &failed);
-  MatchesProxyServerHelper("Bad fallback_proxy", fallback_proxy,

[eroman, 2013/03/06 23:26:32]

Is it intentional that you removed the check on fallback_proxy? Shouldn't this
be translated to fallback_proxies?

[marq_use_my_chromium_address, 2013/03/07 00:34:29]

That was a mistake; fixed.

-                           rules.fallback_proxy, &failure_details, &failed);
+                           rules.proxies_for_https, &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) {
@@ skipping 56 matching lines @@
     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