Data Reduction Proxy: Remove duplicate functions

components/data_reduction_proxy/core/browser/data_reduction_proxy_config_unittest.cc

 // Copyright 2015 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/browser/data_reduction_proxy_config.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
@@ skipping 105 matching lines @@
   void SetUp() override {
     net::NetworkChangeNotifier::SetTestNotificationsOnly(true);
     base::RunLoop().RunUntilIdle();
     network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
 
     test_context_ = DataReductionProxyTestContext::Builder()
                         .WithMockConfig()
                         .WithMockDataReductionProxyService()
                         .Build();
 
-    ResetSettings(true, false);
+    ResetSettings();
 
-    expected_params_.reset(new TestDataReductionProxyParams(
-        DataReductionProxyParams::kPromoAllowed,
-        TestDataReductionProxyParams::HAS_EVERYTHING));
+    expected_params_.reset(new TestDataReductionProxyParams());
   }
 
-  void ResetSettings(bool promo_allowed, bool holdback) {
-    int flags = 0;
-    if (promo_allowed)
-      flags |= DataReductionProxyParams::kPromoAllowed;
-    if (holdback)
-      flags |= DataReductionProxyParams::kHoldback;
-    config()->ResetParamFlagsForTest(flags);
-  }
+  void ResetSettings() { config()->ResetParamFlagsForTest(); }
 
   const scoped_refptr<base::SingleThreadTaskRunner>& task_runner() {
     return message_loop_.task_runner();
   }
 
   class TestResponder {
    public:
     void ExecuteCallback(FetcherResponseCallback callback) {
       callback.Run(response, status, http_response_code);
     }
@@ skipping 77 matching lines @@
 
  private:
   std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   base::MessageLoopForIO message_loop_;
   std::unique_ptr<DataReductionProxyTestContext> test_context_;
   std::unique_ptr<TestDataReductionProxyParams> expected_params_;
 };
 
 TEST_F(DataReductionProxyConfigTest, TestReloadConfigHoldback) {
+  base::FieldTrialList field_trial_list(nullptr);
+  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
+      "DataCompressionProxyHoldback", "Enabled"));
+
   const net::ProxyServer kHttpsProxy = net::ProxyServer::FromURI(
       "https://secure_origin.net:443", net::ProxyServer::SCHEME_HTTP);
   const net::ProxyServer kHttpProxy = net::ProxyServer::FromURI(
       "insecure_origin.net:80", net::ProxyServer::SCHEME_HTTP);
   SetProxiesForHttpOnCommandLine({kHttpsProxy, kHttpProxy});
 
-  ResetSettings(true, true);
+  ResetSettings();
 
   config()->UpdateConfigForTesting(true, false);
   config()->ReloadConfig();
   EXPECT_EQ(std::vector<net::ProxyServer>(), GetConfiguredProxiesForHttp());
 }
 
 TEST_F(DataReductionProxyConfigTest, TestOnIPAddressChanged) {
   const net::URLRequestStatus kSuccess(net::URLRequestStatus::SUCCESS, net::OK);
   const net::ProxyServer kHttpsProxy = net::ProxyServer::FromURI(
       "https://secure_origin.net:443", net::ProxyServer::SCHEME_HTTP);
   const net::ProxyServer kHttpProxy = net::ProxyServer::FromURI(
       "insecure_origin.net:80", net::ProxyServer::SCHEME_HTTP);
 
   SetProxiesForHttpOnCommandLine({kHttpsProxy, kHttpProxy});
-  ResetSettings(true, false);
+  ResetSettings();
 
   // The proxy is enabled initially.
   config()->UpdateConfigForTesting(true, true);
   config()->ReloadConfig();
 
   // IP address change triggers a secure proxy check that succeeds. Proxy
   // remains unrestricted.
   CheckSecureProxyCheckOnIPChange("OK", false, net::HTTP_OK, kSuccess,
                                   SUCCEEDED_PROXY_ALREADY_ENABLED,
                                   {kHttpsProxy, kHttpProxy});
@@ skipping 90 matching lines @@
           true, false,
       },
       {
           true, true,
       },
   };
   for (const auto& test : tests) {
     base::HistogramTester histogram_tester;
     SetProxiesForHttpOnCommandLine({kHttpsProxy, kHttpProxy});
 
-    ResetSettings(true, false);
+    ResetSettings();
 
     variations::testing::ClearAllVariationParams();
     std::map<std::string, std::string> variation_params;
     variation_params["enable_warmup"] =
         test.enabled_via_field_trial ? "true" : "false";
     variation_params["warmup_url"] = warmup_url.spec();
 
     ASSERT_TRUE(variations::AssociateVariationParams(
         params::GetQuicFieldTrialName(), "Enabled", variation_params));
 
     base::FieldTrialList field_trial_list(nullptr);
     base::FieldTrialList::CreateFieldTrial(params::GetQuicFieldTrialName(),
                                            "Enabled");
 
     base::CommandLine::ForCurrentProcess()->InitFromArgv(0, NULL);
-    TestDataReductionProxyConfig config(
-        0, TestDataReductionProxyParams::HAS_EVERYTHING, task_runner(), nullptr,
-        configurator(), event_creator());
+    TestDataReductionProxyConfig config(task_runner(), nullptr, configurator(),
+                                        event_creator());
 
     scoped_refptr<net::URLRequestContextGetter> request_context_getter_ =
         new net::TestURLRequestContextGetter(task_runner());
     config.InitializeOnIOThread(request_context_getter_.get(),
                                 request_context_getter_.get());
 
     // Set the connection type to WiFi so that warm up URL is fetched even if
     // the test device does not have connectivity.
     config.connection_type_ = net::NetworkChangeNotifier::CONNECTION_WIFI;
     config.SetProxyConfig(test.data_reduction_proxy_enabled, true);
@@ skipping 187 matching lines @@
     if (tests[i].allowed)
       proxies.push_back(origin);
     if (tests[i].allowed && tests[i].fallback_allowed)
       proxies.push_back(fallback_origin);
 
     std::string proxy_rules = "http=" + base::JoinString(proxies, ",") +
                               ",direct://;";
 
     rules.ParseFromString(proxy_rules);
 
-    int flags = 0;
-    unsigned int has_definitions = TestDataReductionProxyParams::HAS_EVERYTHING;
     std::unique_ptr<TestDataReductionProxyParams> params(
-        new TestDataReductionProxyParams(flags, has_definitions));
+        new TestDataReductionProxyParams());
     std::unique_ptr<DataReductionProxyConfig> config =
         BuildConfig(std::move(params));
 
     net::ProxyRetryInfoMap retry_map;
     net::ProxyRetryInfo retry_info;
     retry_info.bad_until = base::TimeTicks() + base::TimeDelta::Max();
 
     if (tests[i].origin)
       retry_map[origin] = retry_info;
     if (tests[i].fallback_origin)
@@ skipping 18 matching lines @@
   std::vector<std::string> proxies;
 
   proxies.push_back(origin);
   proxies.push_back(fallback_origin);
 
   std::string proxy_rules =
       "http=" + base::JoinString(proxies, ",") + ",direct://;";
 
   rules.ParseFromString(proxy_rules);
 
-  int flags = 0;
-  unsigned int has_definitions = TestDataReductionProxyParams::HAS_EVERYTHING;
   std::unique_ptr<TestDataReductionProxyParams> params(
-      new TestDataReductionProxyParams(flags, has_definitions));
+      new TestDataReductionProxyParams());
   std::unique_ptr<DataReductionProxyConfig> config =
       BuildConfig(std::move(params));
 
   net::ProxyRetryInfoMap retry_map;
   net::ProxyRetryInfo retry_info;
 
   retry_info.bad_until = base::TimeTicks() + base::TimeDelta::Max();
   retry_map[origin] = retry_info;
 
   retry_info.bad_until = base::TimeTicks();
@@ skipping 44 matching lines @@
        false},
       {net::ProxyServer::FromURI(
            TestDataReductionProxyParams::DefaultFallbackOrigin(),
            net::ProxyServer::SCHEME_HTTP),
        true, net::ProxyServer::FromURI(
                  TestDataReductionProxyParams::DefaultFallbackOrigin(),
                  net::ProxyServer::SCHEME_HTTP),
        net::ProxyServer(), true},
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    int flags = 0;
-    unsigned int has_definitions = TestDataReductionProxyParams::HAS_EVERYTHING;
     std::unique_ptr<TestDataReductionProxyParams> params(
-        new TestDataReductionProxyParams(flags, has_definitions));
+        new TestDataReductionProxyParams());
     DataReductionProxyTypeInfo proxy_type_info;
     std::unique_ptr<DataReductionProxyConfig> config(
         new DataReductionProxyConfig(task_runner(), net_log(),
                                      std::move(params), configurator(),
                                      event_creator()));
     EXPECT_EQ(
         tests[i].expected_result,
         config->IsDataReductionProxy(tests[i].proxy_server, &proxy_type_info))
         << i;
     EXPECT_EQ(tests[i].expected_first.is_valid(),
@@ skipping 546 matching lines @@
 }
 
 // Tests if metrics for Lo-Fi accuracy are recorded properly.
 TEST_F(DataReductionProxyConfigTest, LoFiAccuracy) {
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
 
   std::vector<base::TimeDelta> lofi_accuracy_recording_intervals;
   lofi_accuracy_recording_intervals.push_back(base::TimeDelta::FromSeconds(0));
 
-  TestDataReductionProxyConfig config(
-      0, TestDataReductionProxyParams::HAS_EVERYTHING, task_runner(), nullptr,
-      configurator(), event_creator());
+  TestDataReductionProxyConfig config(task_runner(), nullptr, configurator(),
+                                      event_creator());
   config.SetLofiAccuracyRecordingIntervals(lofi_accuracy_recording_intervals);
   config.SetTickClock(tick_clock.get());
 
   variations::testing::ClearAllVariationParams();
   std::map<std::string, std::string> variation_params;
 
   int expected_hysteresis_sec = 360;
 
   variation_params["effective_connection_type"] = "Slow2G";
   variation_params["hysteresis_period_seconds"] =
@@ skipping 65 matching lines @@
 
 // Tests if metrics for Lo-Fi accuracy are recorded properly at the specified
 // interval.
 TEST_F(DataReductionProxyConfigTest, LoFiAccuracyNonZeroDelay) {
   std::unique_ptr<base::SimpleTestTickClock> tick_clock(
       new base::SimpleTestTickClock());
 
   std::vector<base::TimeDelta> lofi_accuracy_recording_intervals;
   lofi_accuracy_recording_intervals.push_back(base::TimeDelta::FromSeconds(1));
 
-  TestDataReductionProxyConfig config(
-      0, TestDataReductionProxyParams::HAS_EVERYTHING, task_runner(), nullptr,
-      configurator(), event_creator());
+  TestDataReductionProxyConfig config(task_runner(), nullptr, configurator(),
+                                      event_creator());
   config.SetLofiAccuracyRecordingIntervals(lofi_accuracy_recording_intervals);
   config.SetTickClock(tick_clock.get());
 
   variations::testing::ClearAllVariationParams();
   std::map<std::string, std::string> variation_params;
 
   variation_params["effective_connection_type"] = "Slow2G";
 
   ASSERT_TRUE(variations::AssociateVariationParams(
       params::GetLoFiFieldTrialName(), "Enabled", variation_params));
@@ skipping 360 matching lines @@
         "DataReductionProxyPreviewsBlackListTransition", "Enabled");
     EXPECT_FALSE(config()->ShouldAcceptLitePages(*request.get(),
                                                  *previews_decider.get()));
     previews_decider = base::MakeUnique<TestPreviewsDecider>(true);
     EXPECT_TRUE(config()->ShouldAcceptLitePages(*request.get(),
                                                 *previews_decider.get()));
   }
 }
 
 }  // namespace data_reduction_proxy