Enable captive portal detection by default.

chrome/browser/captive_portal/captive_portal_service_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/captive_portal/captive_portal_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 114 matching lines @@
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptivePortalObserver);
 };
 
 }  // namespace
 
 class CaptivePortalServiceTest : public testing::Test {
  public:
-  CaptivePortalServiceTest() {}
+  CaptivePortalServiceTest()
+      : was_service_disabled_for_tests_(
+            CaptivePortalService::is_disabled_for_tests()) {
+  }
 
-  virtual ~CaptivePortalServiceTest() {}
+  virtual ~CaptivePortalServiceTest() {
+    CaptivePortalService::set_is_disabled_for_tests(
+        was_service_disabled_for_tests_);
+  }
 
-  void Initialize(bool enable_on_command_line) {
-    if (enable_on_command_line) {
-      CommandLine::ForCurrentProcess()->AppendSwitch(
-          switches::kCaptivePortalDetection);
-    }
+  // |enable_service| is whether or not the captive portal service itself
+  // should be disabled.  This is different from enabling the captive portal
+  // detection preference.
+  void Initialize(bool enable_service) {
+    CaptivePortalService::set_is_disabled_for_tests(!enable_service);
 
     profile_.reset(new TestingProfile());
     service_.reset(new TestCaptivePortalService(profile_.get()));
     scoped_ptr<TestCaptivePortalService> service_;
 
     // Use no delays for most tests.
     set_initial_backoff_no_portal(base::TimeDelta());
     set_initial_backoff_portal(base::TimeDelta());
 
     // Disable jitter, so can check exact values.
     set_jitter_factor(0.0);
 
     // These values make checking exponential backoff easier.
     set_multiply_factor(2.0);
     set_maximum_backoff(base::TimeDelta::FromSeconds(1600));
 
     // This means backoff starts after the first "failure", which is the second
     // captive portal test in a row that ends up with the same result.
     set_num_errors_to_ignore(0);
 
-    EnableCaptivePortalDetection(true);
+    EnableCaptivePortalDetectionPreference(true);
   }
 
   // Sets the captive portal checking preference.
-  void EnableCaptivePortalDetection(bool enabled) {
+  void EnableCaptivePortalDetectionPreference(bool enabled) {
     profile()->GetPrefs()->SetBoolean(prefs::kAlternateErrorPagesEnabled,
                                       enabled);
   }
 
   // Calls the corresponding CaptivePortalService function.
   void OnURLFetchComplete(net::URLFetcher* fetcher) {
     service()->OnURLFetchComplete(fetcher);
   }
 
   // Triggers a captive portal check, then simulates the URL request
@@ skipping 137 matching lines @@
 
   void set_jitter_factor(double jitter_factor) {
     service()->recheck_policy().backoff_policy.jitter_factor = jitter_factor;
   }
 
   TestingProfile* profile() { return profile_.get(); }
 
   TestCaptivePortalService* service() { return service_.get(); }
 
  private:
+  // Stores the initial value of CaptivePortalService::is_disabled_for_tests
+  // so it can be restored after the test.
+  const bool was_service_disabled_for_tests_;
+
   MessageLoop message_loop_;
 
   // Note that the construction order of these matters.
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<TestCaptivePortalService> service_;
 };
 
 // Test when connected to the Internet and get the expected 204 response.
 TEST_F(CaptivePortalServiceTest, CaptivePortalInternetConnected) {
   Initialize(true);
@@ skipping 92 matching lines @@
 // Check that everything works as expected when captive portal checking is
 // disabled, including throttling.  Then enables it again and runs another test.
 TEST_F(CaptivePortalServiceTest, CaptivePortalPrefDisabled) {
   Initialize(true);
 
   // This value should have no effect on this test.
   set_initial_backoff_no_portal(base::TimeDelta::FromDays(1));
 
   set_initial_backoff_portal(base::TimeDelta::FromSeconds(100));
 
-  EnableCaptivePortalDetection(false);
+  EnableCaptivePortalDetectionPreference(false);
 
   RunDisabledTest(0);
   for (int i = 0; i < 6; ++i)
     RunDisabledTest(100);
 
-  EnableCaptivePortalDetection(true);
+  EnableCaptivePortalDetectionPreference(true);
 
   RunTest(RESULT_BEHIND_CAPTIVE_PORTAL, net::OK, 200, 0, NULL);
 }
 
 // Check that disabling the captive portal service while a check is running
 // works.
 TEST_F(CaptivePortalServiceTest, CaptivePortalPrefDisabledWhileRunning) {
   Initialize(true);
   CaptivePortalObserver observer(profile(), service());
 
   // Needed to create the URLFetcher, even if it never returns any results.
   net::TestURLFetcherFactory factory;
   service()->DetectCaptivePortal();
 
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
 
-  EnableCaptivePortalDetection(false);
+  EnableCaptivePortalDetectionPreference(false);
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
   EXPECT_EQ(0, observer.num_results_received());
 
   MessageLoop::current()->RunAllPending();
 
   EXPECT_FALSE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
   EXPECT_EQ(1, observer.num_results_received());
 
   EXPECT_EQ(RESULT_INTERNET_CONNECTED, observer.captive_portal_result());
 }
 
 // Check that disabling the captive portal service while a check is pending
 // works.
 TEST_F(CaptivePortalServiceTest, CaptivePortalPrefDisabledWhilePending) {
   Initialize(true);
   set_initial_backoff_no_portal(base::TimeDelta::FromDays(1));
 
   // Needed to create the URLFetcher, even if it never returns any results.
   net::TestURLFetcherFactory factory;
 
   CaptivePortalObserver observer(profile(), service());
   service()->DetectCaptivePortal();
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
 
-  EnableCaptivePortalDetection(false);
+  EnableCaptivePortalDetectionPreference(false);
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
   EXPECT_EQ(0, observer.num_results_received());
 
   MessageLoop::current()->RunAllPending();
 
   EXPECT_FALSE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
   EXPECT_EQ(1, observer.num_results_received());
 
   EXPECT_EQ(RESULT_INTERNET_CONNECTED, observer.captive_portal_result());
 }
 
 // Check that disabling the captive portal service while a check is pending
 // works.
 TEST_F(CaptivePortalServiceTest, CaptivePortalPrefEnabledWhilePending) {
   Initialize(true);
 
-  EnableCaptivePortalDetection(false);
+  EnableCaptivePortalDetectionPreference(false);
   RunDisabledTest(0);
 
   CaptivePortalObserver observer(profile(), service());
   service()->DetectCaptivePortal();
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
 
   net::TestURLFetcherFactory factory;
 
-  EnableCaptivePortalDetection(true);
+  EnableCaptivePortalDetectionPreference(true);
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
 
   MessageLoop::current()->RunAllPending();
   ASSERT_TRUE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   fetcher->set_response_code(200);
   OnURLFetchComplete(fetcher);
   EXPECT_FALSE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
 
   EXPECT_EQ(1, observer.num_results_received());
   EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL, observer.captive_portal_result());
 }
 
-// Checks that disabling with a command line flag works as expected.
-TEST_F(CaptivePortalServiceTest, CaptivePortalDisabledAtCommandLine) {
+// Checks that disabling for browser tests works as expected.
+TEST_F(CaptivePortalServiceTest, CaptivePortalDisableForTests) {
   Initialize(false);
   RunDisabledTest(0);
 }
 
 // Checks that jitter gives us values in the correct range.
 TEST_F(CaptivePortalServiceTest, CaptivePortalJitter) {
   Initialize(true);
   set_jitter_factor(0.3);
   set_initial_backoff_no_portal(base::TimeDelta::FromSeconds(100));
   RunTest(RESULT_INTERNET_CONNECTED, net::OK, 204, 0, NULL);
@@ skipping 64 matching lines @@
 
   RunTest(RESULT_NO_RESPONSE,
           net::OK,
           503,
           0,
           "HTTP/1.1 503 OK\nRetry-After: Christmas\n\n");
   EXPECT_EQ(base::TimeDelta::FromSeconds(100), GetTimeUntilNextRequest());
 }
 
 }  // namespace captive_portal