Add probe to warm data reduction proxy

components/data_reduction_proxy/browser/data_reduction_proxy_settings.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.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 286 matching lines @@
 
 DataReductionProxySettings::ContentLengthList
 DataReductionProxySettings::GetDailyReceivedContentLengths() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return GetDailyContentLengths(prefs::kDailyHttpReceivedContentLength);
 }
 
 void DataReductionProxySettings::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  // The purpose of sending a request for the warmup URL is to warm the
+  // connection to the data_reduction_proxy. The result is ignored.
+  if (source == warmup_fetcher_.get())
+    return;
+
+  DCHECK(source == fetcher_.get());
   net::URLRequestStatus status = source->GetStatus();
   if (status.status() == net::URLRequestStatus::FAILED &&
       status.error() == net::ERR_INTERNET_DISCONNECTED) {
     RecordProbeURLFetchResult(INTERNET_DISCONNECTED);
     return;
   }
 
   std::string response;
   source->GetResponseAsString(&response);
 
@@ skipping 75 matching lines @@
 
   LOG(WARNING) << "SPDY proxy " << (enabled ? annotated_on : kOff)
                << " " << (at_startup ? kAtStartup : kByUser);
 }
 
 void DataReductionProxySettings::OnIPAddressChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (enabled_by_user_) {
     DCHECK(params_->allowed());
     ProbeWhetherDataReductionProxyIsAvailable();
+    WarmProxyConnection();
   }
 }
 
 void DataReductionProxySettings::OnProxyEnabledPrefChange() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!params_->allowed())
     return;
   MaybeActivateDataReductionProxy(false);
 }
 
@@ skipping 32 matching lines @@
   }
 
   // Configure use of the data reduction proxy if it is enabled.
   enabled_by_user_= IsDataReductionProxyEnabled();
   SetProxyConfigs(enabled_by_user_,
                   IsDataReductionProxyAlternativeEnabled(),
                   restricted_by_carrier_,
                   at_startup);
 
   // Check if the proxy has been restricted explicitly by the carrier.
-  if (enabled_by_user_)
+  if (enabled_by_user_) {
     ProbeWhetherDataReductionProxyIsAvailable();
+    WarmProxyConnection();
+  }
 }
 
 void DataReductionProxySettings::SetProxyConfigs(bool enabled,
                                                  bool alternative_enabled,
                                                  bool restricted,
                                                  bool at_startup) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LogProxyState(enabled, restricted, at_startup);
   // The alternative is only configured if the standard configuration is
   // is enabled.
@@ skipping 108 matching lines @@
     int64 salt,
     const std::string& key) {
   std::string salted_key =
       base::StringPrintf("%lld%s%lld",
                          static_cast<long long>(salt),
                          key.c_str(),
                          static_cast<long long>(salt));
   return base::UTF8ToUTF16(base::MD5String(salted_key));
 }
 
-net::URLFetcher* DataReductionProxySettings::GetURLFetcher() {
-  DCHECK(url_request_context_getter_);
-  net::URLFetcher* fetcher = net::URLFetcher::Create(params_->probe_url(),
+net::URLFetcher* DataReductionProxySettings::GetBaseURLFetcher(
+    const GURL& gurl,
+    int load_flags) {
+
+  net::URLFetcher* fetcher = net::URLFetcher::Create(gurl,
                                                      net::URLFetcher::GET,
                                                      this);
-  fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE | net::LOAD_BYPASS_PROXY);
+  fetcher->SetLoadFlags(load_flags);
+  DCHECK(url_request_context_getter_);
   fetcher->SetRequestContext(url_request_context_getter_);
   // Configure max retries to be at most kMaxRetries times for 5xx errors.
   static const int kMaxRetries = 5;
   fetcher->SetMaxRetriesOn5xx(kMaxRetries);
   fetcher->SetAutomaticallyRetryOnNetworkChanges(kMaxRetries);
   return fetcher;
 }
 
+
+net::URLFetcher*
+DataReductionProxySettings::GetURLFetcherForAvailabilityCheck() {
+  return GetBaseURLFetcher(params_->probe_url(),
+                           net::LOAD_DISABLE_CACHE | net::LOAD_BYPASS_PROXY);
+}
+
+
 void DataReductionProxySettings::ProbeWhetherDataReductionProxyIsAvailable() {
-  net::URLFetcher* fetcher = GetURLFetcher();
+  net::URLFetcher* fetcher = GetURLFetcherForAvailabilityCheck();
   if (!fetcher)
     return;
   fetcher_.reset(fetcher);
   fetcher_->Start();
 }
 
+net::URLFetcher* DataReductionProxySettings::GetURLFetcherForWarmup() {
+  return GetBaseURLFetcher(params_->warmup_url(), net::LOAD_DISABLE_CACHE);
+}
+
+void DataReductionProxySettings::WarmProxyConnection() {
+  net::URLFetcher* fetcher = GetURLFetcherForWarmup();
+  if (!fetcher)
+    return;
+  warmup_fetcher_.reset(fetcher);
+  warmup_fetcher_->Start();
+}
+
 }  // namespace data_reduction_proxy