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;
+

[marq (ping after 24h), 2014/06/16 17:23:35]

DCHECK(source == fetcher_.get()), so that adding another fetcher and not
handling it here is a programming error.

[bengr, 2014/06/17 03:42:09]

Done.

   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::GetURLFetcher() {

[marq (ping after 24h), 2014/06/16 17:23:34]

I think you can tighten things up a bit and roll the specific fetcher getters
into ProbeWhetherDataReductionProxyIsAvailable() and WarmProxyConnection(), and
just use GetBaseURLFetcher as the injection point for mocks in the tests.
Because the URL gets passed into GetBaseURLFetcher(), the mocking code can
expect calls with specific inputs and return the right response for each URL.

[bengr, 2014/06/17 03:42:09]

This is the way it is to make testing easier. 

+  return GetBaseURLFetcher(params_->probe_url(),
+                           net::LOAD_DISABLE_CACHE | net::LOAD_BYPASS_PROXY);
+}
+
+
 void DataReductionProxySettings::ProbeWhetherDataReductionProxyIsAvailable() {
   net::URLFetcher* fetcher = GetURLFetcher();
   if (!fetcher)
     return;
   fetcher_.reset(fetcher);
   fetcher_->Start();
 }
 
+net::URLFetcher* DataReductionProxySettings::GetURLFetcherForWarmup() {
+  return GetBaseURLFetcher(params_->warmup_url(),
+                           net::LOAD_DISABLE_CACHE);

[marq (ping after 24h), 2014/06/16 17:23:35]

This will fit on one line.

[bengr, 2014/06/17 03:42:09]

Done.

+}
+
+void DataReductionProxySettings::WarmProxyConnection() {
+  net::URLFetcher* fetcher = GetURLFetcherForWarmup();
+  if (!fetcher)
+    return;
+  warmup_fetcher_.reset(fetcher);
+  warmup_fetcher_->Start();
+}
+
 }  // namespace data_reduction_proxy