Removed connection warmup logic from data reduction proxy

components/data_reduction_proxy/browser/data_reduction_proxy_settings_test_utils.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/browser/data_reduction_proxy_settings_test_utils.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_switches.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::Return;
 
 namespace {
 
 const char kProbeURLWithOKResponse[] = "http://ok.org/";
-const char kWarmupURLWithNoContentResponse[] = "http://warm.org/";
 
 const char kProxy[] = "proxy";
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
 // Transform "normal"-looking headers (\n-separated) to the appropriate
 // input format for ParseRawHeaders (\0-separated).
 void HeadersToRaw(std::string* headers) {
@@ skipping 103 matching lines @@
     flags |= DataReductionProxyParams::kHoldback;
   MockDataReductionProxySettings<C>* settings =
       new MockDataReductionProxySettings<C>(flags);
   EXPECT_CALL(*settings, GetOriginalProfilePrefs())
       .Times(AnyNumber())
       .WillRepeatedly(Return(&pref_service_));
   EXPECT_CALL(*settings, GetLocalStatePrefs())
       .Times(AnyNumber())
       .WillRepeatedly(Return(&pref_service_));
   EXPECT_CALL(*settings, GetURLFetcherForAvailabilityCheck()).Times(0);
-  EXPECT_CALL(*settings, GetURLFetcherForWarmup()).Times(0);
   EXPECT_CALL(*settings, LogProxyState(_, _, _)).Times(0);
   settings_.reset(settings);
   configurator_.reset(new TestDataReductionProxyConfig());
   settings_->configurator_ = configurator_.get();
 }
 
 // Explicitly generate required instantiations.
 template void
 DataReductionProxySettingsTestBase::ResetSettings<DataReductionProxySettings>(
     bool allowed,
     bool fallback_allowed,
     bool alt_allowed,
     bool promo_allowed,
     bool holdback);
 
 template <class C>
 void DataReductionProxySettingsTestBase::SetProbeResult(
     const std::string& test_url,
-    const std::string& warmup_test_url,
     const std::string& response,
     ProbeURLFetchResult result,
     bool success,
     int expected_calls)  {
   MockDataReductionProxySettings<C>* settings =
       static_cast<MockDataReductionProxySettings<C>*>(settings_.get());
   if (0 == expected_calls) {
     EXPECT_CALL(*settings, GetURLFetcherForAvailabilityCheck()).Times(0);
-    EXPECT_CALL(*settings, GetURLFetcherForWarmup()).Times(0);
     EXPECT_CALL(*settings, RecordProbeURLFetchResult(_)).Times(0);
   } else {
     EXPECT_CALL(*settings, RecordProbeURLFetchResult(result)).Times(1);
     EXPECT_CALL(*settings, GetURLFetcherForAvailabilityCheck())
         .Times(expected_calls)
         .WillRepeatedly(Return(new net::FakeURLFetcher(
             GURL(test_url),
             settings,
             response,
             success ? net::HTTP_OK : net::HTTP_INTERNAL_SERVER_ERROR,
             success ? net::URLRequestStatus::SUCCESS :
                       net::URLRequestStatus::FAILED)));
-    EXPECT_CALL(*settings, GetURLFetcherForWarmup())
-        .Times(expected_calls)
-        .WillRepeatedly(Return(new net::FakeURLFetcher(
-            GURL(warmup_test_url),
-            settings,
-            "",
-            success ? net::HTTP_NO_CONTENT : net::HTTP_INTERNAL_SERVER_ERROR,
-                success ? net::URLRequestStatus::SUCCESS :
-                          net::URLRequestStatus::FAILED)));
   }
 }
 
 // Explicitly generate required instantiations.
 template void
 DataReductionProxySettingsTestBase::SetProbeResult<DataReductionProxySettings>(
     const std::string& test_url,
-    const std::string& warmup_test_url,
     const std::string& response,
     ProbeURLFetchResult result,
     bool success,
     int expected_calls);
 
 void DataReductionProxySettingsTestBase::CheckProxyConfigs(
     bool expected_enabled,
     bool expected_restricted,
     bool expected_fallback_restricted) {
   TestDataReductionProxyConfig* config =
       static_cast<TestDataReductionProxyConfig*>(settings_->configurator_);
   ASSERT_EQ(expected_restricted, config->restricted_);
   ASSERT_EQ(expected_fallback_restricted, config->fallback_restricted_);
   ASSERT_EQ(expected_enabled, config->enabled_);
 }
 
 void DataReductionProxySettingsTestBase::CheckProbe(
     bool initially_enabled,
     const std::string& probe_url,
-    const std::string& warmup_url,
     const std::string& response,
     bool request_succeeded,
     bool expected_enabled,
     bool expected_restricted,
     bool expected_fallback_restricted) {
   pref_service_.SetBoolean(prefs::kDataReductionProxyEnabled,
                            initially_enabled);
   if (initially_enabled)
     settings_->enabled_by_user_ = true;
   settings_->restricted_by_carrier_ = false;
   SetProbeResult(probe_url,
-                 warmup_url,
                  response,
                  FetchResult(initially_enabled,
                              request_succeeded && (response == "OK")),
                  request_succeeded,
                  initially_enabled ? 1 : 0);
   settings_->MaybeActivateDataReductionProxy(false);
   base::MessageLoop::current()->RunUntilIdle();
   CheckProxyConfigs(expected_enabled,
                     expected_restricted,
                     expected_fallback_restricted);
 }
 
 void DataReductionProxySettingsTestBase::CheckProbeOnIPChange(
     const std::string& probe_url,
-    const std::string& warmup_url,
     const std::string& response,
     bool request_succeeded,
     bool expected_restricted,
     bool expected_fallback_restricted) {
   SetProbeResult(probe_url,
-                 warmup_url,
                  response,
                  FetchResult(!settings_->restricted_by_carrier_,
                              request_succeeded && (response == "OK")),
                  request_succeeded,
                  1);
   settings_->OnIPAddressChanged();
   base::MessageLoop::current()->RunUntilIdle();
   CheckProxyConfigs(true, expected_restricted, expected_fallback_restricted);
 }
 
 void DataReductionProxySettingsTestBase::CheckOnPrefChange(
     bool enabled,
     bool expected_enabled,
     bool managed) {
   // Always have a sucessful probe for pref change tests.
   SetProbeResult(kProbeURLWithOKResponse,
-                 kWarmupURLWithNoContentResponse,
                  "OK",
                  FetchResult(enabled, true),
                  true,
                  expected_enabled ? 1 : 0);
   if (managed) {
     pref_service_.SetManagedPref(prefs::kDataReductionProxyEnabled,
                                  new base::FundamentalValue(enabled));
   } else {
     pref_service_.SetBoolean(prefs::kDataReductionProxyEnabled, enabled);
   }
   base::MessageLoop::current()->RunUntilIdle();
   // Never expect the proxy to be restricted for pref change tests.
   CheckProxyConfigs(expected_enabled, false, false);
 }
 
 void DataReductionProxySettingsTestBase::CheckInitDataReductionProxy(
     bool enabled_at_startup) {
   base::MessageLoopForUI loop;
   SetProbeResult(kProbeURLWithOKResponse,
-                 kWarmupURLWithNoContentResponse,
                  "OK",
                  FetchResult(enabled_at_startup, true),
                  true,
                  enabled_at_startup ? 1 : 0);
   scoped_ptr<DataReductionProxyConfigurator> configurator(
       new TestDataReductionProxyConfig());
   settings_->SetProxyConfigurator(configurator.get());
   scoped_refptr<net::TestURLRequestContextGetter> request_context =
       new net::TestURLRequestContextGetter(base::MessageLoopProxy::current());
 
   settings_->InitDataReductionProxySettings(
       &pref_service_,
       &pref_service_,
       request_context.get());
   settings_->SetOnDataReductionEnabledCallback(
       base::Bind(&DataReductionProxySettingsTestBase::
                  RegisterSyntheticFieldTrialCallback,
                  base::Unretained(this)));
 
   base::MessageLoop::current()->RunUntilIdle();
   CheckProxyConfigs(enabled_at_startup, false, false);
   EXPECT_EQ(enabled_at_startup, proxy_enabled_);
 }
 
 }  // namespace data_reduction_proxy