Data Reduction Proxy: Remove duplicate functions

components/data_reduction_proxy/core/common/data_reduction_proxy_params_unittest.cc

 // Copyright 2014 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 "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_server.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
 #include "components/data_reduction_proxy/proto/client_config.pb.h"
 #include "components/variations/variations_associated_data.h"
 #include "net/proxy/proxy_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace data_reduction_proxy {
 class DataReductionProxyParamsTest : public testing::Test {
  public:
   void CheckParams(const TestDataReductionProxyParams& params,
-                   bool expected_init_result,
-                   bool expected_promo_allowed) {
+                   bool expected_init_result) {
     EXPECT_EQ(expected_init_result, params.init_result());
-    EXPECT_EQ(expected_promo_allowed, params.promo_allowed());
   }
   void CheckValues(const TestDataReductionProxyParams& params,
                    const std::string& expected_origin,
                    const std::string& expected_fallback_origin,
                    const std::string& expected_secure_proxy_check_url) {
     std::vector<net::ProxyServer> expected_proxies;
     if (!expected_origin.empty()) {
       expected_proxies.push_back(net::ProxyServer::FromURI(
           expected_origin, net::ProxyServer::SCHEME_HTTP));
     }
 
     if (!expected_fallback_origin.empty()) {
       expected_proxies.push_back(net::ProxyServer::FromURI(
           expected_fallback_origin, net::ProxyServer::SCHEME_HTTP));
     }
 
     EXPECT_EQ(expected_proxies,
               DataReductionProxyServer::ConvertToNetProxyServers(
                   params.proxies_for_http()));
     EXPECT_EQ(GURL(expected_secure_proxy_check_url),
               params.secure_proxy_check_url());
   }
 };
 
 TEST_F(DataReductionProxyParamsTest, EverythingDefined) {
-  TestDataReductionProxyParams params(
-      DataReductionProxyParams::kPromoAllowed,
-      TestDataReductionProxyParams::HAS_EVERYTHING);
-  CheckParams(params, true, true);
+  TestDataReductionProxyParams params;
+  CheckParams(params, true);
   std::vector<DataReductionProxyServer> expected_proxies;
 
   // Both the origin and fallback proxy must have type CORE.
   expected_proxies.push_back(DataReductionProxyServer(
       net::ProxyServer::FromURI(TestDataReductionProxyParams::DefaultOrigin(),
                                 net::ProxyServer::SCHEME_HTTP),
       ProxyServer::CORE));
   expected_proxies.push_back(DataReductionProxyServer(
       net::ProxyServer::FromURI(
           TestDataReductionProxyParams::DefaultFallbackOrigin(),
           net::ProxyServer::SCHEME_HTTP),
       ProxyServer::CORE));
 
   EXPECT_EQ(expected_proxies, params.proxies_for_http());
   EXPECT_EQ(GURL(TestDataReductionProxyParams::DefaultSecureProxyCheckURL()),
             params.secure_proxy_check_url());
 }
 
 TEST_F(DataReductionProxyParamsTest, Flags) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kDataReductionProxy,
       TestDataReductionProxyParams::FlagOrigin());
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kDataReductionProxyFallback,
       TestDataReductionProxyParams::FlagFallbackOrigin());
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kDataReductionProxySecureProxyCheckURL,
       TestDataReductionProxyParams::FlagSecureProxyCheckURL());
-  TestDataReductionProxyParams params(
-      DataReductionProxyParams::kPromoAllowed,
-      TestDataReductionProxyParams::HAS_EVERYTHING);
-  CheckParams(params, true, true);
+  TestDataReductionProxyParams params;
+  CheckParams(params, true);
   CheckValues(params, TestDataReductionProxyParams::FlagOrigin(),
               TestDataReductionProxyParams::FlagFallbackOrigin(),
               TestDataReductionProxyParams::FlagSecureProxyCheckURL());
 }
 
 TEST_F(DataReductionProxyParamsTest, CarrierTestFlag) {
   static const char kCarrierTestOrigin[] =
       "http://o-o.preferred.nttdocomodcp-hnd1.proxy-dev.googlezip.net:80";
   static const char kDefaultFallbackOrigin[] = "compress.googlezip.net:80";
   base::CommandLine::ForCurrentProcess()->InitFromArgv(0, nullptr);
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEnableDataReductionProxyCarrierTest, kCarrierTestOrigin);
-  DataReductionProxyParams params(0);
+  DataReductionProxyParams params;
   std::vector<DataReductionProxyServer> proxies_for_http;
   proxies_for_http.push_back(DataReductionProxyServer(
       net::ProxyServer::FromURI(kCarrierTestOrigin,
                                 net::ProxyServer::SCHEME_HTTP),
       ProxyServer::CORE));
   proxies_for_http.push_back(DataReductionProxyServer(
       net::ProxyServer::FromURI(kDefaultFallbackOrigin,
                                 net::ProxyServer::SCHEME_HTTP),
       ProxyServer::CORE));
   EXPECT_EQ(params.proxies_for_http(), proxies_for_http);
 }
 
-TEST_F(DataReductionProxyParamsTest, InvalidConfigurations) {
-  const struct {
-    bool promo_allowed;
-    unsigned int missing_definitions;
-    bool expected_result;
-  } tests[] = {
-      {true, TestDataReductionProxyParams::HAS_NOTHING, true},
-      {true, TestDataReductionProxyParams::HAS_ORIGIN, false},
-      {true, TestDataReductionProxyParams::HAS_FALLBACK_ORIGIN, false},
-      {true, TestDataReductionProxyParams::HAS_SECURE_PROXY_CHECK_URL, false},
-  };
-
-  for (size_t i = 0; i < arraysize(tests); ++i) {
-    int flags = 0;
-    if (tests[i].promo_allowed)
-      flags |= DataReductionProxyParams::kPromoAllowed;
-    TestDataReductionProxyParams params(
-        flags,
-        TestDataReductionProxyParams::HAS_EVERYTHING &
-            ~(tests[i].missing_definitions));
-    EXPECT_EQ(tests[i].expected_result, params.init_result()) << i;
-  }
-}
-
 TEST_F(DataReductionProxyParamsTest, AndroidOnePromoFieldTrial) {
-  EXPECT_TRUE(params::IsIncludedInAndroidOnePromoFieldTrial(
+  EXPECT_TRUE(params::IsIncludedInAndroidOnePromoFieldTrialForTesting(
       "google/sprout/sprout:4.4.4/KPW53/1379542:user/release-keys"));
-  EXPECT_FALSE(params::IsIncludedInAndroidOnePromoFieldTrial(
+  EXPECT_FALSE(params::IsIncludedInAndroidOnePromoFieldTrialForTesting(
       "google/hammerhead/hammerhead:5.0/LRX210/1570415:user/release-keys"));
 }
 
 TEST_F(DataReductionProxyParamsTest, IsClientConfigEnabled) {
   const struct {
     std::string test_case;
     std::string trial_group_value;
     bool expected;
   } tests[] = {
       {
@@ skipping 396 matching lines @@
           switches::kDataReductionProxyConfigURL, test.flag_value);
     }
     EXPECT_EQ(test.expected, params::GetConfigServiceURL()) << test.test_case;
   }
 }
 
 TEST(DataReductionProxyParamsStandaloneTest, OverrideProxiesForHttp) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kDataReductionProxyHttpProxies,
       "http://override-first.net;http://override-second.net");
-  DataReductionProxyParams params(0);
+  DataReductionProxyParams params;
 
   // Overriding proxies must have type UNSPECIFIED_TYPE.
   std::vector<DataReductionProxyServer> expected_override_proxies_for_http;
   expected_override_proxies_for_http.push_back(DataReductionProxyServer(
       net::ProxyServer::FromURI("http://override-first.net",
                                 net::ProxyServer::SCHEME_HTTP),
       ProxyServer::UNSPECIFIED_TYPE));
   expected_override_proxies_for_http.push_back(DataReductionProxyServer(
       net::ProxyServer::FromURI("http://override-second.net",
                                 net::ProxyServer::SCHEME_HTTP),
       ProxyServer::UNSPECIFIED_TYPE));
 
   EXPECT_EQ(expected_override_proxies_for_http, params.proxies_for_http());
 }
 
 }  // namespace data_reduction_proxy