Base Data Reduction Proxy configuration on vectors of servers per origin scheme.

components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc

Index: components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc
diff --git a/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc b/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc
index f6f522c1b7c1e2cc2e21014fc691cc11507761c6..6707d645ad6094088c5ea7c3602615ea4e8e0254 100644
--- a/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc
+++ b/components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc
@@ -4,10 +4,13 @@
 
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h"
 
+#include <vector>
+
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config_test_utils.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_configurator_test_utils.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_mutable_config_values.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_service.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_event_creator.h"
@@ -74,12 +77,8 @@ class DataReductionProxyConfigTest : public testing::Test {
     EXPECT_CALL(*config(), RecordSecureProxyCheckFetchResult(result)).Times(1);
   }
 
-  void CheckProxyConfigs(bool expected_enabled,
-                         bool expected_restricted,
-                         bool expected_fallback_restricted) {
+  void CheckProxyConfigs(bool expected_enabled, bool expected_restricted) {
     ASSERT_EQ(expected_restricted, configurator()->restricted());
-    ASSERT_EQ(expected_fallback_restricted,
-              configurator()->fallback_restricted());
     ASSERT_EQ(expected_enabled, configurator()->enabled());
   }
 
@@ -110,7 +109,7 @@ class DataReductionProxyConfigTest : public testing::Test {
             testing::Invoke(&responder, &TestResponder::ExecuteCallback)));
     config()->OnIPAddressChanged();
     test_context_->RunUntilIdle();
-    CheckProxyConfigs(true, expected_restricted, expected_fallback_restricted);
+    CheckProxyConfigs(true, expected_restricted);
   }
 
   void RunUntilIdle() {
@@ -137,6 +136,12 @@ class DataReductionProxyConfigTest : public testing::Test {
     return expected_params_.get();
   }
 
+  DataReductionProxyEventCreator* event_creator() const {
+    return test_context_->event_creator();
+  }
+
+  net::NetLog* net_log() const { return test_context_->net_log(); }
+
  private:
   base::MessageLoopForIO message_loop_;
   scoped_ptr<DataReductionProxyTestContext> test_context_;
@@ -156,42 +161,42 @@ TEST_F(DataReductionProxyConfigTest, TestUpdateConfigurator) {
   config()->UpdateConfigurator(true, true, false, false);
   EXPECT_TRUE(configurator()->enabled());
 
-  EXPECT_EQ(
-      net::ProxyServer::FromURI(
-          params()->DefaultAltOrigin(),
-          net::ProxyServer::SCHEME_HTTP),
-          net::ProxyServer::FromURI(configurator()->origin(),
-                                    net::ProxyServer::SCHEME_HTTP));
-  EXPECT_TRUE(net::ProxyServer::FromURI(
-      params()->DefaultAltFallbackOrigin(),
-      net::ProxyServer::SCHEME_HTTP).is_valid());
-  EXPECT_TRUE(configurator()->fallback_origin().empty());
-  EXPECT_EQ(net::ProxyServer::FromURI(params()->DefaultSSLOrigin(),
-                                      net::ProxyServer::SCHEME_HTTP),
-            net::ProxyServer::FromURI(configurator()->ssl_origin(),
-                                      net::ProxyServer::SCHEME_HTTP));
+  std::vector<net::ProxyServer> expected_http_proxies;
+  expected_http_proxies.push_back(net::ProxyServer::FromURI(
+      params()->DefaultAltOrigin(), net::ProxyServer::SCHEME_HTTP));
+  std::vector<net::ProxyServer> expected_https_proxies;
+  expected_https_proxies.push_back(net::ProxyServer::FromURI(
+      params()->DefaultSSLOrigin(), net::ProxyServer::SCHEME_HTTP));
+  EXPECT_TRUE(
+      net::ProxyServer::FromURI(params()->DefaultAltFallbackOrigin(),
+                                net::ProxyServer::SCHEME_HTTP).is_valid());
+  EXPECT_THAT(expected_http_proxies,
+              testing::ContainerEq(configurator()->proxies_for_http()));
+  EXPECT_THAT(expected_https_proxies,
+              testing::ContainerEq(configurator()->proxies_for_https()));
 
   config()->UpdateConfigurator(true, false, false, false);
+  expected_http_proxies.clear();
+  expected_https_proxies.clear();
   EXPECT_TRUE(configurator()->enabled());
-  EXPECT_TRUE(
-      net::HostPortPair::FromString(params()->DefaultOrigin())
-          .Equals(net::HostPortPair::FromString(configurator()->origin())));
-  EXPECT_TRUE(net::HostPortPair::FromString(params()->DefaultFallbackOrigin())
-                  .Equals(net::HostPortPair::FromString(
-                      configurator()->fallback_origin())));
-  EXPECT_TRUE(configurator()->ssl_origin().empty());
+  expected_http_proxies.push_back(net::ProxyServer::FromURI(
+      params()->DefaultOrigin(), net::ProxyServer::SCHEME_HTTP));
+  expected_http_proxies.push_back(net::ProxyServer::FromURI(
+      params()->DefaultFallbackOrigin(), net::ProxyServer::SCHEME_HTTP));
+  EXPECT_THAT(expected_http_proxies,
+              testing::ContainerEq(configurator()->proxies_for_http()));
+  EXPECT_THAT(expected_https_proxies,
+              testing::ContainerEq(configurator()->proxies_for_https()));
 
   config()->UpdateConfigurator(false, true, false, false);
   EXPECT_FALSE(configurator()->enabled());
-  EXPECT_TRUE(configurator()->origin().empty());
-  EXPECT_TRUE(configurator()->fallback_origin().empty());
-  EXPECT_TRUE(configurator()->ssl_origin().empty());
+  EXPECT_TRUE(configurator()->proxies_for_http().empty());
+  EXPECT_TRUE(configurator()->proxies_for_https().empty());
 
   config()->UpdateConfigurator(false, false, false, false);
   EXPECT_FALSE(configurator()->enabled());
-  EXPECT_TRUE(configurator()->origin().empty());
-  EXPECT_TRUE(configurator()->fallback_origin().empty());
-  EXPECT_TRUE(configurator()->ssl_origin().empty());
+  EXPECT_TRUE(configurator()->proxies_for_http().empty());
+  EXPECT_TRUE(configurator()->proxies_for_https().empty());
 }
 
 TEST_F(DataReductionProxyConfigTest, TestUpdateConfiguratorHoldback) {
@@ -199,9 +204,8 @@ TEST_F(DataReductionProxyConfigTest, TestUpdateConfiguratorHoldback) {
 
   config()->UpdateConfigurator(true, true, false, false);
   EXPECT_FALSE(configurator()->enabled());
-  EXPECT_EQ("", configurator()->origin());
-  EXPECT_EQ("", configurator()->fallback_origin());
-  EXPECT_EQ("", configurator()->ssl_origin());
+  EXPECT_TRUE(configurator()->proxies_for_http().empty());
+  EXPECT_TRUE(configurator()->proxies_for_https().empty());
 }
 
 TEST_F(DataReductionProxyConfigTest, TestOnIPAddressChanged) {
@@ -236,7 +240,7 @@ TEST_F(DataReductionProxyConfigTest, TestOnIPAddressChanged) {
       ));
   config()->OnIPAddressChanged();
   RunUntilIdle();
-  CheckProxyConfigs(false, false, false);
+  CheckProxyConfigs(false, false);
 
   // Check that the proxy is re-enabled if a non-VPN connection is later used.
   config()->interfaces()->clear();
@@ -291,7 +295,7 @@ TEST_F(DataReductionProxyConfigTest,
       ));
   config()->OnIPAddressChanged();
   RunUntilIdle();
-  CheckProxyConfigs(false, false, false);
+  CheckProxyConfigs(false, false);
 
   // Check that the proxy is re-enabled if a non-VPN connection is later used.
   config()->interfaces()->clear();
@@ -777,4 +781,308 @@ TEST_F(DataReductionProxyConfigTest, AreProxiesBypassedRetryDelay) {
   EXPECT_EQ(delay, min_retry_delay);
 }
 
+TEST_F(DataReductionProxyConfigTest, IsDataReductionProxyWithParams) {
+  const struct {
+    net::HostPortPair host_port_pair;
+    bool fallback_allowed;
+    bool alt_fallback_allowed;
+    bool set_dev_origin;
+    bool expected_result;
+    net::HostPortPair expected_first;
+    net::HostPortPair expected_second;
+    bool expected_is_fallback;
+    bool expected_is_alternative;
+    bool expected_is_ssl;
+  } tests[] = {
+      {net::ProxyServer::FromURI(TestDataReductionProxyParams::DefaultOrigin(),
+                                 net::ProxyServer::SCHEME_HTTP)
+           .host_port_pair(),
+       true,
+       true,
+       false,
+       true,
+       net::ProxyServer::FromURI(TestDataReductionProxyParams::DefaultOrigin(),
+                                 net::ProxyServer::SCHEME_HTTP)
+           .host_port_pair(),
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       false,
+       false,
+       false},
+      {net::ProxyServer::FromURI(TestDataReductionProxyParams::DefaultOrigin(),
+                                 net::ProxyServer::SCHEME_HTTP)
+           .host_port_pair(),
+       false,
+       false,
+       false,
+       true,
+       net::ProxyServer::FromURI(TestDataReductionProxyParams::DefaultOrigin(),
+                                 net::ProxyServer::SCHEME_HTTP)
+           .host_port_pair(),
+       net::HostPortPair::FromURL(GURL()),
+       false,
+       false,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       true,
+       true,
+       false,
+       true,
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       net::HostPortPair::FromURL(GURL()),
+       true,
+       false,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       false,
+       false,
+       false,
+       false,
+       net::HostPortPair::FromURL(GURL()),
+       net::HostPortPair::FromURL(GURL()),
+       false,
+       false,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       true,
+       true,
+       false,
+       true,
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       false,
+       true,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       false,
+       false,
+       false,
+       true,
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       net::HostPortPair::FromURL(GURL()),
+       false,
+       true,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       true,
+       true,
+       false,
+       true,
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       net::HostPortPair::FromURL(GURL()),
+       true,
+       true,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultAltFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       false,
+       false,
+       false,
+       false,
+       net::HostPortPair::FromURL(GURL()),
+       net::HostPortPair::FromURL(GURL()),
+       false,
+       false,
+       false},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultSSLOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       true,
+       true,
+       false,
+       true,
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultSSLOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       net::HostPortPair::FromURL(GURL()),
+       false,
+       true,
+       true},
+      {net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultDevOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       true,
+       true,
+       true,
+       true,
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultDevOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       net::ProxyServer::FromURI(
+           TestDataReductionProxyParams::DefaultDevFallbackOrigin(),
+           net::ProxyServer::SCHEME_HTTP).host_port_pair(),
+       false,
+       false,
+       false},
+      {net::ProxyServer::FromURI(TestDataReductionProxyParams::DefaultOrigin(),
+                                 net::ProxyServer::SCHEME_HTTP)
+           .host_port_pair(),
+       true,
+       true,
+       true,
+       false,
+       net::HostPortPair::FromURL(GURL()),
+       net::HostPortPair::FromURL(GURL()),
+       false,
+       false,
+       false},
+  };
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    int flags = DataReductionProxyParams::kAllowed |
+                DataReductionProxyParams::kAlternativeAllowed;
+    if (tests[i].fallback_allowed)
+      flags |= DataReductionProxyParams::kFallbackAllowed;
+    if (tests[i].alt_fallback_allowed)
+      flags |= DataReductionProxyParams::kAlternativeFallbackAllowed;
+    unsigned int has_definitions = TestDataReductionProxyParams::HAS_EVERYTHING;
+    if (!tests[i].set_dev_origin) {
+      has_definitions &= ~TestDataReductionProxyParams::HAS_DEV_ORIGIN;
+      has_definitions &= ~TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN;
+    }
+    scoped_ptr<TestDataReductionProxyParams> params(
+        new TestDataReductionProxyParams(flags, has_definitions));
+    DataReductionProxyTypeInfo proxy_type_info;
+    scoped_ptr<DataReductionProxyConfig> config(new DataReductionProxyConfig(
+        net_log(), params.Pass(), configurator(), event_creator()));
+    EXPECT_EQ(
+        tests[i].expected_result,
+        config->IsDataReductionProxy(tests[i].host_port_pair, &proxy_type_info))
+        << i;
+    EXPECT_EQ(
+        net::ProxyServer::FromURI(tests[i].expected_first.ToString(),
+                                  net::ProxyServer::SCHEME_HTTP).is_valid(),
+        proxy_type_info.proxy_servers.size() >= 1 &&
+            proxy_type_info.proxy_servers[0].is_valid())
+        << i;
+    if (proxy_type_info.proxy_servers.size() >= 1 &&
+        proxy_type_info.proxy_servers[0].is_valid()) {
+      EXPECT_TRUE(tests[i].expected_first.Equals(
+          proxy_type_info.proxy_servers[0].host_port_pair()))
+          << i;
+    }
+    EXPECT_EQ(
+        net::ProxyServer::FromURI(tests[i].expected_second.ToString(),
+                                  net::ProxyServer::SCHEME_HTTP).is_valid(),
+        proxy_type_info.proxy_servers.size() >= 2 &&
+            proxy_type_info.proxy_servers[1].is_valid())
+        << i;
+    if (proxy_type_info.proxy_servers.size() >= 2 &&
+        proxy_type_info.proxy_servers[1].is_valid()) {
+      EXPECT_TRUE(tests[i].expected_second.Equals(
+          proxy_type_info.proxy_servers[1].host_port_pair()))
+          << i;
+    }
+
+    EXPECT_EQ(tests[i].expected_is_fallback, proxy_type_info.is_fallback) << i;
+    EXPECT_EQ(tests[i].expected_is_alternative, proxy_type_info.is_alternative)
+        << i;
+    EXPECT_EQ(tests[i].expected_is_ssl, proxy_type_info.is_ssl) << i;
+  }
+}
+
+TEST_F(DataReductionProxyConfigTest, IsDataReductionProxyWithMutableConfig) {
+  std::vector<net::ProxyServer> proxies_for_http;
+  proxies_for_http.push_back(net::ProxyServer::FromURI(
+      "https://origin.net:443", net::ProxyServer::SCHEME_HTTP));
+  proxies_for_http.push_back(net::ProxyServer::FromURI(
+      "http://origin.net:80", net::ProxyServer::SCHEME_HTTP));
+  proxies_for_http.push_back(net::ProxyServer::FromURI(
+      "quic://anotherorigin.net:443", net::ProxyServer::SCHEME_HTTP));
+  const struct {
+    net::HostPortPair host_port_pair;
+    bool expected_result;
+    net::ProxyServer expected_first;
+    net::ProxyServer expected_second;
+    net::ProxyServer expected_third;
+    bool expected_is_fallback;
+  } tests[] = {
+      {
+       proxies_for_http[0].host_port_pair(),
+       true,
+       proxies_for_http[0],
+       proxies_for_http[1],
+       proxies_for_http[2],
+       false,
+      },
+      {
+       proxies_for_http[1].host_port_pair(),
+       true,
+       proxies_for_http[1],
+       proxies_for_http[2],
+       net::ProxyServer(),
+       true,
+      },
+      {
+       proxies_for_http[2].host_port_pair(),
+       true,
+       proxies_for_http[2],
+       net::ProxyServer(),
+       net::ProxyServer(),
+       true,
+      },
+      {
+       net::HostPortPair(),
+       false,
+       net::ProxyServer(),
+       net::ProxyServer(),
+       net::ProxyServer(),
+       false,
+      },
+      {
+       net::HostPortPair::FromString("https://otherorigin.net:443"),
+       false,
+       net::ProxyServer(),
+       net::ProxyServer(),
+       net::ProxyServer(),
+       false,
+      },
+  };
+
+  scoped_ptr<DataReductionProxyMutableConfigValues> config_values =
+      DataReductionProxyMutableConfigValues::CreateFromParams(params());
+  config_values->UpdateValues(proxies_for_http);
+  scoped_ptr<DataReductionProxyConfig> config(new DataReductionProxyConfig(
+      net_log(), config_values.Pass(), configurator(), event_creator()));
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    DataReductionProxyTypeInfo proxy_type_info;
+    EXPECT_EQ(tests[i].expected_result,
+              config->IsDataReductionProxy(tests[i].host_port_pair,
+                                           &proxy_type_info));
+    std::vector<net::ProxyServer> expected_proxy_servers;
+    if (tests[i].expected_first.is_valid())
+      expected_proxy_servers.push_back(tests[i].expected_first);
+    if (tests[i].expected_second.is_valid())
+      expected_proxy_servers.push_back(tests[i].expected_second);
+    if (tests[i].expected_third.is_valid())
+      expected_proxy_servers.push_back(tests[i].expected_third);
+    EXPECT_THAT(proxy_type_info.proxy_servers,
+                testing::ContainerEq(expected_proxy_servers))
+        << i;
+    EXPECT_FALSE(proxy_type_info.is_alternative) << i;
+    EXPECT_FALSE(proxy_type_info.is_ssl) << i;
+  }
+}
+
 }  // namespace data_reduction_proxy