components/data_reduction_proxy/browser/data_reduction_proxy_params_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
   6
   7 #include <map>
   8
   9 #include "base/command_line.h"
  10 #include "base/logging.h"
  11 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params_test_utils.h"
  12 #include "components/data_reduction_proxy/common/data_reduction_proxy_switches.h"
  13 #include "net/proxy/proxy_retry_info.h"
  14 #include "net/proxy/proxy_server.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace data_reduction_proxy {
  18 class DataReductionProxyParamsTest : public testing::Test {
  19  public:
  20   void CheckParams(const TestDataReductionProxyParams& params,
  21                    bool expected_init_result,
  22                    bool expected_allowed,
  23                    bool expected_fallback_allowed,
  24                    bool expected_alternative_allowed,
  25                    bool expected_promo_allowed) {
  26     EXPECT_EQ(expected_init_result, params.init_result());
  27     EXPECT_EQ(expected_allowed, params.allowed());
  28     EXPECT_EQ(expected_fallback_allowed, params.fallback_allowed());
  29     EXPECT_EQ(expected_alternative_allowed, params.alternative_allowed());
  30     EXPECT_EQ(expected_promo_allowed, params.promo_allowed());
  31   }
  32   void CheckValues(const TestDataReductionProxyParams& params,
  33                    const std::string& expected_origin,
  34                    const std::string& expected_fallback_origin,
  35                    const std::string& expected_ssl_origin,
  36                    const std::string& expected_alt_origin,
  37                    const std::string& expected_alt_fallback_origin,
  38                    const std::string& expected_probe_url) {
  39     EXPECT_EQ(GURL(expected_origin), params.origin());
  40     EXPECT_EQ(GURL(expected_fallback_origin), params.fallback_origin());
  41     EXPECT_EQ(GURL(expected_ssl_origin), params.ssl_origin());
  42     EXPECT_EQ(GURL(expected_alt_origin), params.alt_origin());
  43     EXPECT_EQ(GURL(expected_alt_fallback_origin), params.alt_fallback_origin());
  44     EXPECT_EQ(GURL(expected_probe_url), params.probe_url());
  45   }
  46 };
  47
  48 TEST_F(DataReductionProxyParamsTest, EverythingDefined) {
  49   TestDataReductionProxyParams params(
  50       DataReductionProxyParams::kAllowed |
  51       DataReductionProxyParams::kFallbackAllowed |
  52       DataReductionProxyParams::kPromoAllowed,
  53       TestDataReductionProxyParams::HAS_EVERYTHING);
  54   CheckParams(params, true, true, true, false, true);
  55   CheckValues(params,
  56               TestDataReductionProxyParams::DefaultDevOrigin(),
  57               TestDataReductionProxyParams::DefaultDevFallbackOrigin(),
  58               TestDataReductionProxyParams::DefaultSSLOrigin(),
  59               TestDataReductionProxyParams::DefaultAltOrigin(),
  60               TestDataReductionProxyParams::DefaultAltFallbackOrigin(),
  61               TestDataReductionProxyParams::DefaultProbeURL());
  62 }
  63
  64 TEST_F(DataReductionProxyParamsTest, NoDevOrigin) {
  65   TestDataReductionProxyParams params(
  66       DataReductionProxyParams::kAllowed |
  67       DataReductionProxyParams::kFallbackAllowed |
  68       DataReductionProxyParams::kPromoAllowed,
  69       TestDataReductionProxyParams::HAS_EVERYTHING &
  70       ~TestDataReductionProxyParams::HAS_DEV_ORIGIN &
  71       ~TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN);
  72   CheckParams(params, true, true, true, false, true);
  73   CheckValues(params,
  74               TestDataReductionProxyParams::DefaultOrigin(),
  75               TestDataReductionProxyParams::DefaultFallbackOrigin(),
  76               TestDataReductionProxyParams::DefaultSSLOrigin(),
  77               TestDataReductionProxyParams::DefaultAltOrigin(),
  78               TestDataReductionProxyParams::DefaultAltFallbackOrigin(),
  79               TestDataReductionProxyParams::DefaultProbeURL());
  80 }
  81
  82 TEST_F(DataReductionProxyParamsTest, Flags) {
  83   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  84       switches::kDataReductionProxy,
  85       TestDataReductionProxyParams::FlagOrigin());
  86   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  87       switches::kDataReductionProxyFallback,
  88       TestDataReductionProxyParams::FlagFallbackOrigin());
  89   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  90       switches::kDataReductionSSLProxy,
  91       TestDataReductionProxyParams::FlagSSLOrigin());
  92   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  93       switches::kDataReductionProxyAlt,
  94       TestDataReductionProxyParams::FlagAltOrigin());
  95   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  96       switches::kDataReductionProxyAltFallback,
  97       TestDataReductionProxyParams::FlagAltFallbackOrigin());
  98   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
  99       switches::kDataReductionProxyProbeURL,
 100       TestDataReductionProxyParams::FlagProbeURL());
 101   TestDataReductionProxyParams params(
 102       DataReductionProxyParams::kAllowed |
 103       DataReductionProxyParams::kFallbackAllowed |
 104       DataReductionProxyParams::kAlternativeAllowed |
 105       DataReductionProxyParams::kPromoAllowed,
 106       TestDataReductionProxyParams::HAS_EVERYTHING);
 107   CheckParams(params, true, true, true, true, true);
 108   CheckValues(params,
 109               TestDataReductionProxyParams::FlagOrigin(),
 110               TestDataReductionProxyParams::FlagFallbackOrigin(),
 111               TestDataReductionProxyParams::FlagSSLOrigin(),
 112               TestDataReductionProxyParams::FlagAltOrigin(),
 113               TestDataReductionProxyParams::FlagAltFallbackOrigin(),
 114               TestDataReductionProxyParams::FlagProbeURL());
 115 }
 116
 117 TEST_F(DataReductionProxyParamsTest, InvalidConfigurations) {
 118   const struct {
 119     bool allowed;
 120     bool fallback_allowed;
 121     bool alternative_allowed;
 122     bool alternative_fallback_allowed;
 123     bool promo_allowed;
 124     unsigned int missing_definitions;
 125     bool expected_result;
 126   } tests[]  = {
 127     {
 128       true,
 129       true,
 130       true,
 131       false,
 132       true,
 133       TestDataReductionProxyParams::HAS_NOTHING,
 134       true
 135     },
 136     {
 137       true,
 138       true,
 139       true,
 140       false,
 141       true,
 142       TestDataReductionProxyParams::HAS_DEV_ORIGIN |
 143           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 144       true
 145     },
 146     {
 147       true,
 148       true,
 149       true,
 150       false,
 151       true,
 152       TestDataReductionProxyParams::HAS_ORIGIN,
 153       true
 154     },
 155     {
 156       true,
 157       true,
 158       true,
 159       false,
 160       true,
 161       TestDataReductionProxyParams::HAS_ORIGIN |
 162           TestDataReductionProxyParams::HAS_DEV_ORIGIN |
 163           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 164       false
 165     },
 166     {
 167       true,
 168       true,
 169       true,
 170       false,
 171       true,
 172       TestDataReductionProxyParams::HAS_FALLBACK_ORIGIN |
 173           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 174       false
 175     },
 176     {
 177       true,
 178       true,
 179       true,
 180       false,
 181       true,
 182       TestDataReductionProxyParams::HAS_SSL_ORIGIN,
 183       false
 184     },
 185     {
 186       true,
 187       true,
 188       true,
 189       false,
 190       true,
 191       TestDataReductionProxyParams::HAS_ALT_ORIGIN,
 192       false
 193     },
 194     {
 195       true,
 196       true,
 197       true,
 198       false,
 199       true,
 200       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 201       true
 202     },
 203     {
 204       true,
 205       true,
 206       true,
 207       true,
 208       true,
 209       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 210       false
 211     },
 212     {
 213       true,
 214       true,
 215       true,
 216       false,
 217       true,
 218       TestDataReductionProxyParams::HAS_PROBE_URL,
 219       false
 220     },
 221     {
 222       true,
 223       false,
 224       true,
 225       false,
 226       true,
 227       TestDataReductionProxyParams::HAS_NOTHING,
 228       true
 229     },
 230     {
 231       true,
 232       false,
 233       true,
 234       false,
 235       true,
 236       TestDataReductionProxyParams::HAS_ORIGIN |
 237           TestDataReductionProxyParams::HAS_DEV_ORIGIN |
 238           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 239       false
 240     },
 241     {
 242       true,
 243       false,
 244       true,
 245       false,
 246       true,
 247       TestDataReductionProxyParams::HAS_FALLBACK_ORIGIN,
 248       true
 249     },
 250     {
 251       true,
 252       false,
 253       true,
 254       false,
 255       true,
 256       TestDataReductionProxyParams::HAS_SSL_ORIGIN,
 257       false
 258     },
 259     {
 260       true,
 261       false,
 262       true,
 263       false,
 264       true,
 265       TestDataReductionProxyParams::HAS_ALT_ORIGIN,
 266       false
 267     },
 268     {
 269       true,
 270       false,
 271       true,
 272       false,
 273       true,
 274       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 275       true
 276     },
 277     {
 278       true,
 279       false,
 280       true,
 281       true,
 282       true,
 283       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 284       false
 285     },
 286     {
 287       true,
 288       false,
 289       true,
 290       false,
 291       true,
 292       TestDataReductionProxyParams::HAS_PROBE_URL,
 293       false
 294     },
 295     {
 296       true,
 297       true,
 298       false,
 299       false,
 300       true,
 301       TestDataReductionProxyParams::HAS_NOTHING,
 302       true
 303     },
 304     {
 305       true,
 306       true,
 307       false,
 308       false,
 309       true,
 310       TestDataReductionProxyParams::HAS_ORIGIN |
 311           TestDataReductionProxyParams::HAS_DEV_ORIGIN |
 312           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 313       false
 314     },
 315     {
 316       true,
 317       true,
 318       false,
 319       false,
 320       true,
 321       TestDataReductionProxyParams::HAS_FALLBACK_ORIGIN |
 322           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 323       false
 324     },
 325     {
 326       true,
 327       true,
 328       false,
 329       false,
 330       true,
 331       TestDataReductionProxyParams::HAS_SSL_ORIGIN,
 332       true
 333     },
 334     {
 335       true,
 336       true,
 337       false,
 338       false,
 339       true,
 340       TestDataReductionProxyParams::HAS_ALT_ORIGIN,
 341       true
 342     },
 343     {
 344       true,
 345       true,
 346       false,
 347       false,
 348       true,
 349       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 350       true
 351     },
 352     {
 353       true,
 354       true,
 355       false,
 356       true,
 357       true,
 358       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 359       false
 360     },
 361     {
 362       true,
 363       true,
 364       false,
 365       false,
 366       true,
 367       TestDataReductionProxyParams::HAS_PROBE_URL,
 368       false
 369     },
 370     {
 371       true,
 372       false,
 373       false,
 374       false,
 375       true,
 376       TestDataReductionProxyParams::HAS_ORIGIN |
 377           TestDataReductionProxyParams::HAS_DEV_ORIGIN |
 378           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 379       false
 380     },
 381     {
 382       true,
 383       false,
 384       false,
 385       false,
 386       true,
 387       TestDataReductionProxyParams::HAS_FALLBACK_ORIGIN,
 388       true
 389     },
 390     {
 391       true,
 392       false,
 393       false,
 394       false,
 395       true,
 396       TestDataReductionProxyParams::HAS_SSL_ORIGIN,
 397       true
 398     },
 399     {
 400       true,
 401       false,
 402       false,
 403       false,
 404       true,
 405       TestDataReductionProxyParams::HAS_ALT_ORIGIN,
 406       true
 407     },
 408     {
 409       true,
 410       false,
 411       false,
 412       false,
 413       true,
 414       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 415       true
 416     },
 417     {
 418       true,
 419       false,
 420       false,
 421       true,
 422       true,
 423       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 424       false
 425     },
 426     {
 427       true,
 428       false,
 429       false,
 430       false,
 431       true,
 432       TestDataReductionProxyParams::HAS_PROBE_URL,
 433       false
 434     },
 435     {
 436       false,
 437       true,
 438       true,
 439       false,
 440       true,
 441       TestDataReductionProxyParams::HAS_NOTHING,
 442       false
 443     },
 444     {
 445       false,
 446       true,
 447       true,
 448       false,
 449       true,
 450       TestDataReductionProxyParams::HAS_ORIGIN |
 451           TestDataReductionProxyParams::HAS_DEV_ORIGIN |
 452           TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN,
 453       false
 454     },
 455     {
 456       false,
 457       true,
 458       true,
 459       false,
 460       true,
 461       TestDataReductionProxyParams::HAS_FALLBACK_ORIGIN,
 462       false
 463     },
 464     {
 465       false,
 466       true,
 467       true,
 468       false,
 469       true,
 470       TestDataReductionProxyParams::HAS_SSL_ORIGIN,
 471       false
 472     },
 473     {
 474       false,
 475       true,
 476       true,
 477       false,
 478       true,
 479       TestDataReductionProxyParams::HAS_ALT_ORIGIN,
 480       false
 481     },
 482     {
 483       false,
 484       true,
 485       true,
 486       false,
 487       true,
 488       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 489       false
 490     },
 491     {
 492       false,
 493       true,
 494       true,
 495       true,
 496       true,
 497       TestDataReductionProxyParams::HAS_ALT_FALLBACK_ORIGIN,
 498       false
 499     },
 500     {
 501       false,
 502       true,
 503       true,
 504       false,
 505       true,
 506       TestDataReductionProxyParams::HAS_PROBE_URL,
 507       false
 508     },
 509   };
 510
 511   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 512     int flags = 0;
 513     if (tests[i].allowed)
 514       flags |= DataReductionProxyParams::kAllowed;
 515     if (tests[i].fallback_allowed)
 516       flags |= DataReductionProxyParams::kFallbackAllowed;
 517     if (tests[i].alternative_allowed)
 518       flags |= DataReductionProxyParams::kAlternativeAllowed;
 519     if (tests[i].alternative_fallback_allowed)
 520       flags |= DataReductionProxyParams::kAlternativeFallbackAllowed;
 521     if (tests[i].promo_allowed)
 522       flags |= DataReductionProxyParams::kPromoAllowed;
 523     TestDataReductionProxyParams params(
 524         flags,
 525         TestDataReductionProxyParams::HAS_EVERYTHING &
 526             ~(tests[i].missing_definitions));
 527     EXPECT_EQ(tests[i].expected_result, params.init_result()) << i;
 528   }
 529 }
 530
 531 TEST_F(DataReductionProxyParamsTest, IsDataReductionProxy) {
 532   const struct {
 533     net::HostPortPair host_port_pair;
 534     bool fallback_allowed;
 535     bool alt_fallback_allowed;
 536     bool set_dev_origin;
 537     bool expected_result;
 538     net::HostPortPair expected_first;
 539     net::HostPortPair expected_second;
 540     bool expected_is_fallback;
 541     bool expected_is_alternative;
 542     bool expected_is_ssl;
 543   } tests[]  = {
 544       {
 545         net::HostPortPair::FromURL(GURL(
 546             TestDataReductionProxyParams::DefaultOrigin())),
 547         true,
 548         true,
 549         false,
 550         true,
 551         net::HostPortPair::FromURL(GURL(
 552             TestDataReductionProxyParams::DefaultOrigin())),
 553         net::HostPortPair::FromURL(GURL(
 554             TestDataReductionProxyParams::DefaultFallbackOrigin())),
 555         false,
 556         false,
 557         false
 558       },
 559       {
 560         net::HostPortPair::FromURL(GURL(
 561             TestDataReductionProxyParams::DefaultOrigin())),
 562         false,
 563         false,
 564         false,
 565         true,
 566         net::HostPortPair::FromURL(GURL(
 567             TestDataReductionProxyParams::DefaultOrigin())),
 568         net::HostPortPair::FromURL(GURL()),
 569         false,
 570         false,
 571         false
 572       },
 573       {
 574         net::HostPortPair::FromURL(GURL(
 575             TestDataReductionProxyParams::DefaultFallbackOrigin())),
 576         true,
 577         true,
 578         false,
 579         true,
 580         net::HostPortPair::FromURL(GURL(
 581             TestDataReductionProxyParams::DefaultFallbackOrigin())),
 582         net::HostPortPair::FromURL(GURL()),
 583         true,
 584         false,
 585         false
 586       },
 587       {
 588         net::HostPortPair::FromURL(GURL(
 589             TestDataReductionProxyParams::DefaultFallbackOrigin())),
 590         false,
 591         false,
 592         false,
 593         false,
 594         net::HostPortPair::FromURL(GURL()),
 595         net::HostPortPair::FromURL(GURL()),
 596         false,
 597         false,
 598         false
 599       },
 600       {
 601         net::HostPortPair::FromURL(GURL(
 602             TestDataReductionProxyParams::DefaultAltOrigin())),
 603         true,
 604         true,
 605         false,
 606         true,
 607         net::HostPortPair::FromURL(GURL(
 608             TestDataReductionProxyParams::DefaultAltOrigin())),
 609         net::HostPortPair::FromURL(GURL(
 610             TestDataReductionProxyParams::DefaultAltFallbackOrigin())),
 611         false,
 612         true,
 613         false
 614       },
 615       {
 616         net::HostPortPair::FromURL(GURL(
 617             TestDataReductionProxyParams::DefaultAltOrigin())),
 618         false,
 619         false,
 620         false,
 621         true,
 622         net::HostPortPair::FromURL(GURL(
 623             TestDataReductionProxyParams::DefaultAltOrigin())),
 624         net::HostPortPair::FromURL(GURL()),
 625         false,
 626         true,
 627         false
 628       },
 629       {
 630         net::HostPortPair::FromURL(
 631             GURL(TestDataReductionProxyParams::DefaultAltFallbackOrigin())),
 632         true,
 633         true,
 634         false,
 635         true,
 636         net::HostPortPair::FromURL(GURL(
 637             TestDataReductionProxyParams::DefaultAltFallbackOrigin())),
 638         net::HostPortPair::FromURL(GURL()),
 639         true,
 640         true,
 641         false
 642       },
 643       {
 644         net::HostPortPair::FromURL(GURL(
 645             TestDataReductionProxyParams::DefaultAltFallbackOrigin())),
 646         false,
 647         false,
 648         false,
 649         false,
 650         net::HostPortPair::FromURL(GURL()),
 651         net::HostPortPair::FromURL(GURL()),
 652         false,
 653         false,
 654         false
 655       },
 656       {
 657         net::HostPortPair::FromURL(GURL(
 658             TestDataReductionProxyParams::DefaultSSLOrigin())),
 659         true,
 660         true,
 661         false,
 662         true,
 663         net::HostPortPair::FromURL(GURL(
 664             TestDataReductionProxyParams::DefaultSSLOrigin())),
 665         net::HostPortPair::FromURL(GURL()),
 666         false,
 667         false,
 668         true
 669       },
 670       {
 671         net::HostPortPair::FromURL(GURL(
 672             TestDataReductionProxyParams::DefaultDevOrigin())),
 673         true,
 674         true,
 675         true,
 676         true,
 677         net::HostPortPair::FromURL(GURL(
 678             TestDataReductionProxyParams::DefaultDevOrigin())),
 679         net::HostPortPair::FromURL(GURL(
 680             TestDataReductionProxyParams::DefaultDevFallbackOrigin())),
 681         false,
 682         false,
 683         false
 684       },
 685       {
 686         net::HostPortPair::FromURL(GURL(
 687             TestDataReductionProxyParams::DefaultOrigin())),
 688         true,
 689         true,
 690         true,
 691         false,
 692         net::HostPortPair::FromURL(GURL()),
 693         net::HostPortPair::FromURL(GURL()),
 694         false,
 695         false,
 696         false
 697       },
 698   };
 699   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 700     int flags = DataReductionProxyParams::kAllowed |
 701                 DataReductionProxyParams::kAlternativeAllowed;
 702     if (tests[i].fallback_allowed)
 703       flags |= DataReductionProxyParams::kFallbackAllowed;
 704     if (tests[i].alt_fallback_allowed)
 705       flags |= DataReductionProxyParams::kAlternativeFallbackAllowed;
 706     unsigned int has_definitions = TestDataReductionProxyParams::HAS_EVERYTHING;
 707     if (!tests[i].set_dev_origin) {
 708       has_definitions &= ~TestDataReductionProxyParams::HAS_DEV_ORIGIN;
 709       has_definitions &= ~TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN;
 710     }
 711     TestDataReductionProxyParams params(flags, has_definitions);
 712     DataReductionProxyTypeInfo proxy_type_info;
 713     EXPECT_EQ(tests[i].expected_result,
 714               params.IsDataReductionProxy(
 715                   tests[i].host_port_pair, &proxy_type_info)) << i;
 716     EXPECT_TRUE(tests[i].expected_first.Equals(
 717         net::HostPortPair::FromURL(proxy_type_info.proxy_servers.first))) << i;
 718     EXPECT_TRUE(tests[i].expected_second.Equals(
 719         net::HostPortPair::FromURL(proxy_type_info.proxy_servers.second))) << i;
 720     EXPECT_EQ(tests[i].expected_is_fallback, proxy_type_info.is_fallback) << i;
 721     EXPECT_EQ(tests[i].expected_is_alternative, proxy_type_info.is_alternative)
 722         << i;
 723     EXPECT_EQ(tests[i].expected_is_ssl, proxy_type_info.is_ssl) << i;
 724   }
 725 }
 726
 727 std::string GetRetryMapKeyFromOrigin(std::string origin) {
 728   // The retry map has the scheme prefix for https but not for http
 729   return net::ProxyServer(GURL(origin).SchemeIs(url::kHttpsScheme) ?
 730       net::ProxyServer::SCHEME_HTTPS : net::ProxyServer::SCHEME_HTTP,
 731       net::HostPortPair::FromURL(GURL(origin))).ToURI();
 732 }
 733
 734 TEST_F(DataReductionProxyParamsTest, AreProxiesBypassed) {
 735   const struct {
 736     // proxy flags
 737     bool allowed;
 738     bool fallback_allowed;
 739     bool alt_allowed;
 740     // is https request
 741     bool is_https;
 742     // proxies in retry map
 743     bool origin;
 744     bool fallback_origin;
 745     bool alt_origin;
 746     bool alt_fallback_origin;
 747     bool ssl_origin;
 748
 749     bool expected_result;
 750   } tests[]  = {
 751       { // proxy flags
 752         false,
 753         false,
 754         false,
 755         // is https request
 756         false,
 757         // proxies in retry map
 758         false,
 759         false,
 760         false,
 761         false,
 762         false,
 763         // expected result
 764         false,
 765       },
 766       { // proxy flags
 767         true,
 768         false,
 769         false,
 770         // is https request
 771         false,
 772         // proxies in retry map
 773         false,
 774         false,
 775         false,
 776         false,
 777         false,
 778         // expected result
 779         false,
 780       },
 781       { // proxy flags
 782         true,
 783         true,
 784         false,
 785         // is https request
 786         false,
 787         // proxies in retry map
 788         false,
 789         false,
 790         false,
 791         false,
 792         false,
 793         // expected result
 794         false,
 795       },
 796       { // proxy flags
 797         true,
 798         true,
 799         true,
 800         // is https request
 801         false,
 802         // proxies in retry map
 803         false,
 804         false,
 805         false,
 806         false,
 807         false,
 808         // expected result
 809         false,
 810       },
 811       { // proxy flags
 812         true,
 813         true,
 814         true,
 815         // is https request
 816         true,
 817         // proxies in retry map
 818         false,
 819         false,
 820         false,
 821         false,
 822         false,
 823         // expected result
 824         false,
 825       },
 826       { // proxy flags
 827         false,
 828         false,
 829         true,
 830         // is https request
 831         true,
 832         // proxies in retry map
 833         false,
 834         false,
 835         false,
 836         false,
 837         true,
 838         // expected result
 839         true,
 840       },
 841       { // proxy flags
 842         true,
 843         true,
 844         true,
 845         // is https request
 846         true,
 847         // proxies in retry map
 848         false,
 849         false,
 850         false,
 851         false,
 852         true,
 853         // expected result
 854         true,
 855       },
 856       { // proxy flags
 857         true,
 858         false,
 859         false,
 860         // is https request
 861         false,
 862         // proxies in retry map
 863         true,
 864         false,
 865         false,
 866         false,
 867         false,
 868         // expected result
 869         true,
 870       },
 871       { // proxy flags
 872         true,
 873         true,
 874         false,
 875         // is https request
 876         false,
 877         // proxies in retry map
 878         false,
 879         true,
 880         false,
 881         false,
 882         false,
 883         // expected result
 884         true,
 885       },
 886       { // proxy flags
 887         false,
 888         true,
 889         true,
 890         // is https request
 891         false,
 892         // proxies in retry map
 893         false,
 894         false,
 895         false,
 896         true,
 897         false,
 898         // expected result
 899         true,
 900       },
 901       { // proxy flags
 902         true,
 903         true,
 904         false,
 905         // is https request
 906         false,
 907         // proxies in retry map
 908         true,
 909         false,
 910         false,
 911         false,
 912         false,
 913         // expected result
 914         false,
 915       },
 916       { // proxy flags
 917         true,
 918         true,
 919         false,
 920         // is https request
 921         false,
 922         // proxies in retry map
 923         true,
 924         true,
 925         false,
 926         false,
 927         false,
 928         // expected result
 929         true,
 930       },
 931       { // proxy flags
 932         true,
 933         true,
 934         true,
 935         // is https request
 936         false,
 937         // proxies in retry map
 938         true,
 939         true,
 940         false,
 941         false,
 942         false,
 943         // expected result
 944         true,
 945       },
 946       { // proxy flags
 947         true,
 948         true,
 949         true,
 950         // is https request
 951         false,
 952         // proxies in retry map
 953         true,
 954         false,
 955         true,
 956         false,
 957         false,
 958         // expected result
 959         false,
 960       },
 961       { // proxy flags
 962         true,
 963         true,
 964         true,
 965         // is https request
 966         false,
 967         // proxies in retry map
 968         false,
 969         false,
 970         true,
 971         true,
 972         false,
 973         // expected result
 974         true,
 975       },
 976       { // proxy flags
 977         false,
 978         true,
 979         true,
 980         // is https request
 981         false,
 982         // proxies in retry map
 983         false,
 984         false,
 985         true,
 986         true,
 987         false,
 988         // expected result
 989         true,
 990       },
 991       { // proxy flags
 992         false,
 993         true,
 994         false,
 995         // is https request
 996         false,
 997         // proxies in retry map
 998         false,
 999         false,
1000         true,
1001         false,
1002         false,
1003         // expected result
1004         false,
1005       },
1006       { // proxy flags
1007         true,
1008         true,
1009         true,
1010         // is https request
1011         false,
1012         // proxies in retry map
1013         true,
1014         false,
1015         true,
1016         true,
1017         false,
1018         // expected result
1019         true,
1020       },
1021       { // proxy flags
1022         true,
1023         true,
1024         true,
1025         // is https request
1026         false,
1027         // proxies in retry map
1028         true,
1029         true,
1030         true,
1031         true,
1032         true,
1033         // expected result
1034         true,
1035       },
1036       { // proxy flags
1037         true,
1038         true,
1039         true,
1040         // is https request
1041         true,
1042         // proxies in retry map
1043         true,
1044         true,
1045         true,
1046         true,
1047         true,
1048         // expected result
1049         true,
1050       },
1051       { // proxy flags
1052         true,
1053         true,
1054         true,
1055         // is https request
1056         true,
1057         // proxies in retry map
1058         true,
1059         true,
1060         true,
1061         true,
1062         false,
1063         // expected result
1064         false,
1065       },
1066   };
1067
1068   // The retry map has the scheme prefix for https but not for http.
1069   std::string origin = GetRetryMapKeyFromOrigin(
1070       TestDataReductionProxyParams::DefaultOrigin());
1071   std::string fallback_origin =GetRetryMapKeyFromOrigin(
1072       TestDataReductionProxyParams::DefaultFallbackOrigin());
1073   std::string alt_origin = GetRetryMapKeyFromOrigin(
1074       TestDataReductionProxyParams::DefaultAltOrigin());
1075   std::string alt_fallback_origin = GetRetryMapKeyFromOrigin(
1076       TestDataReductionProxyParams::DefaultAltFallbackOrigin());
1077   std::string ssl_origin = GetRetryMapKeyFromOrigin(
1078       TestDataReductionProxyParams::DefaultSSLOrigin());
1079
1080   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
1081     int flags = 0;
1082     if (tests[i].allowed)
1083       flags |= DataReductionProxyParams::kAllowed;
1084     if (tests[i].alt_allowed)
1085       flags |= DataReductionProxyParams::kAlternativeAllowed;
1086     if (tests[i].fallback_allowed)
1087       flags |= DataReductionProxyParams::kFallbackAllowed;
1088     unsigned int has_definitions =
1089         TestDataReductionProxyParams::HAS_EVERYTHING &
1090         ~TestDataReductionProxyParams::HAS_DEV_ORIGIN &
1091         ~TestDataReductionProxyParams::HAS_DEV_FALLBACK_ORIGIN;
1092     TestDataReductionProxyParams params(flags, has_definitions);
1093
1094     net::ProxyRetryInfoMap retry_map;
1095     net::ProxyRetryInfo retry_info;
1096
1097     if (tests[i].origin)
1098       retry_map[origin] = retry_info;
1099     if (tests[i].fallback_origin)
1100       retry_map[fallback_origin] = retry_info;
1101     if (tests[i].alt_origin)
1102       retry_map[alt_origin] = retry_info;
1103     if (tests[i].alt_fallback_origin)
1104       retry_map[alt_fallback_origin] = retry_info;
1105     if (tests[i].ssl_origin)
1106       retry_map[ssl_origin] = retry_info;
1107
1108     bool was_bypassed = params.AreProxiesBypassed(retry_map,
1109                                                   tests[i].is_https,
1110                                                   NULL);
1111
1112     EXPECT_EQ(tests[i].expected_result, was_bypassed);
1113   }
1114 }
1115 }  // namespace data_reduction_proxy