Add probe to warm data reduction proxy

components/data_reduction_proxy/browser/data_reduction_proxy_settings_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/browser/data_reduction_proxy_settings.h"
 
 #include "base/command_line.h"
 #include "base/md5.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 13 matching lines @@
 const char kDataReductionProxyDev[] = "http://foo-dev.com:80";
 const char kDataReductionProxyFallback[] = "http://bar.com:80";
 const char kDataReductionProxyKey[] = "12345";
 const char kDataReductionProxyAlt[] = "https://alt.com:443/";
 const char kDataReductionProxyAltFallback[] = "http://alt2.com:80";
 const char kDataReductionProxySSL[] = "http://ssl.com:80";
 
 const char kProbeURLWithOKResponse[] = "http://ok.org/";
 const char kProbeURLWithBadResponse[] = "http://bad.org/";
 const char kProbeURLWithNoResponse[] = "http://no.org/";
+const char kWarmupURLWithNoContentResponse[] = "http://warm.org/";
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
 class DataReductionProxySettingsTest
     : public ConcreteDataReductionProxySettingsTest<
           DataReductionProxySettings> {
 };
 
@@ skipping 106 matching lines @@
 
   settings_->SetProxyConfigs(false, false, false, false);
   EXPECT_FALSE(config->enabled_);
   EXPECT_EQ("", config->origin_);
   EXPECT_EQ("", config->fallback_origin_);
   EXPECT_EQ("", config->ssl_origin_);
 }
 
 TEST_F(DataReductionProxySettingsTest, TestIsProxyEnabledOrManaged) {
   settings_->InitPrefMembers();
-    base::MessageLoopForUI loop;
-    // The proxy is disabled initially.
-    settings_->enabled_by_user_ = false;
-    settings_->SetProxyConfigs(false, false, false, false);
+  base::MessageLoopForUI loop;
+  // The proxy is disabled initially.
+  settings_->enabled_by_user_ = false;
+  settings_->SetProxyConfigs(false, false, false, false);
 
   EXPECT_FALSE(settings_->IsDataReductionProxyEnabled());
   EXPECT_FALSE(settings_->IsDataReductionProxyManaged());
 
   CheckOnPrefChange(true, true, false);
   EXPECT_TRUE(settings_->IsDataReductionProxyEnabled());
   EXPECT_FALSE(settings_->IsDataReductionProxyManaged());
 
   CheckOnPrefChange(true, true, true);
   EXPECT_TRUE(settings_->IsDataReductionProxyEnabled());
   EXPECT_TRUE(settings_->IsDataReductionProxyManaged());
+
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(DataReductionProxySettingsTest, TestAcceptableChallenges) {
   typedef struct {
     std::string host;
     std::string realm;
     bool expected_to_succeed;
   } challenge_test;
 
   challenge_test tests[] = {
@@ skipping 117 matching lines @@
       prefs::kDataReductionProxyEnabled,
       settings_->GetOriginalProfilePrefs());
   settings_->data_reduction_proxy_alternative_enabled_.Init(
       prefs::kDataReductionProxyAltEnabled,
       settings_->GetOriginalProfilePrefs());
 
   // TODO(bengr): Test enabling/disabling while a probe is outstanding.
   base::MessageLoopForUI loop;
   // The proxy is enabled and unrestructed initially.
   // Request succeeded but with bad response, expect proxy to be restricted.
-  CheckProbe(true, kProbeURLWithBadResponse, "Bad", true, true, true, false);
+  CheckProbe(true,
+             kProbeURLWithBadResponse,
+             kWarmupURLWithNoContentResponse,
+             "Bad",
+             true,
+             true,
+             true,
+             false);
   // Request succeeded with valid response, expect proxy to be unrestricted.
-  CheckProbe(true, kProbeURLWithOKResponse, "OK", true, true, false, false);
+  CheckProbe(true,
+             kProbeURLWithOKResponse,
+             kWarmupURLWithNoContentResponse,
+             "OK",
+             true,
+             true,
+             false,
+             false);
   // Request failed, expect proxy to be enabled but restricted.
-  CheckProbe(true, kProbeURLWithNoResponse, "", false, true, true, false);
+  CheckProbe(true,
+             kProbeURLWithNoResponse,
+             kWarmupURLWithNoContentResponse,
+             "",
+             false,
+             true,
+             true,
+             false);
   // The proxy is disabled initially. Probes should not be emitted to change
   // state.
-  CheckProbe(false, kProbeURLWithOKResponse, "OK", true, false, false, false);
+  CheckProbe(false,
+             kProbeURLWithOKResponse,
+             kWarmupURLWithNoContentResponse,
+             "OK",
+             true,
+             false,
+             false,
+             false);
 }
 
 TEST_F(DataReductionProxySettingsTest, TestOnIPAddressChanged) {
   base::MessageLoopForUI loop;
   // The proxy is enabled initially.
   pref_service_.SetBoolean(prefs::kDataReductionProxyEnabled, true);
   settings_->spdy_proxy_auth_enabled_.Init(
       prefs::kDataReductionProxyEnabled,
       settings_->GetOriginalProfilePrefs());
   settings_->data_reduction_proxy_alternative_enabled_.Init(
       prefs::kDataReductionProxyAltEnabled,
       settings_->GetOriginalProfilePrefs());
   settings_->enabled_by_user_ = true;
   settings_->restricted_by_carrier_ = false;
   settings_->SetProxyConfigs(true, false, false, true);
   // IP address change triggers a probe that succeeds. Proxy remains
   // unrestricted.
-  CheckProbeOnIPChange(kProbeURLWithOKResponse, "OK", true, false, false);
+  CheckProbeOnIPChange(kProbeURLWithOKResponse,
+                       kWarmupURLWithNoContentResponse,
+                       "OK",
+                       true,
+                       false,
+                       false);
   // IP address change triggers a probe that fails. Proxy is restricted.
-  CheckProbeOnIPChange(kProbeURLWithBadResponse, "Bad", true, true, false);
+  CheckProbeOnIPChange(kProbeURLWithBadResponse,
+                       kWarmupURLWithNoContentResponse,
+                       "Bad",
+                       true,
+                       true,
+                       false);
   // IP address change triggers a probe that fails. Proxy remains restricted.
-  CheckProbeOnIPChange(kProbeURLWithBadResponse, "Bad", true, true, false);
+  CheckProbeOnIPChange(kProbeURLWithBadResponse,
+                       kWarmupURLWithNoContentResponse,
+                       "Bad",
+                       true,
+                       true,
+                       false);
   // IP address change triggers a probe that succeed. Proxy is unrestricted.
-  CheckProbeOnIPChange(kProbeURLWithBadResponse, "OK", true, false, false);
+  CheckProbeOnIPChange(kProbeURLWithBadResponse,
+                       kWarmupURLWithNoContentResponse,
+                       "OK",
+                       true,
+                       false,
+                       false);
 }
 
 TEST_F(DataReductionProxySettingsTest, TestOnProxyEnabledPrefChange) {
   settings_->InitPrefMembers();
   base::MessageLoopForUI loop;
   // The proxy is enabled initially.
   settings_->enabled_by_user_ = true;
   settings_->SetProxyConfigs(true, false, false, true);
   // The pref is disabled, so correspondingly should be the proxy.
   CheckOnPrefChange(false, false, false);
@@ skipping 60 matching lines @@
   scoped_refptr<net::TestURLRequestContextGetter> request_context =
       new net::TestURLRequestContextGetter(base::MessageLoopProxy::current());
   settings_->InitDataReductionProxySettings(&pref_service_,
                                             &pref_service_,
                                             request_context.get());
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace data_reduction_proxy