Added detection timeouts and usage of Retry-After HTTP header.

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/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
 #include "chrome/browser/captive_portal/testing_utils.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "net/base/net_errors.h"
-#include "net/http/http_response_headers.h"
-#include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace captive_portal {
 
 namespace {
 
 // A short amount of time that some tests wait for.
 const int kShortTimeMs = 10;
 
 // An observer watches the CaptivePortalDetector.  It tracks the last
@@ skipping 120 matching lines @@
     base::TimeDelta expected_delay =
         base::TimeDelta::FromSeconds(expected_delay_secs);
 
     ASSERT_EQ(CaptivePortalService::STATE_IDLE, service()->state());
     ASSERT_EQ(expected_delay, GetTimeUntilNextRequest());
 
     AdvanceTime(expected_delay);
     ASSERT_EQ(base::TimeDelta(), GetTimeUntilNextRequest());
 
     CaptivePortalObserver observer(profile(), service());
-    net::TestURLFetcherFactory factory;
     service()->DetectCaptivePortal();
 
     EXPECT_EQ(CaptivePortalService::STATE_TIMER_RUNNING, service()->state());
     EXPECT_FALSE(FetchingURL());
     ASSERT_TRUE(TimerRunning());
 
     MessageLoop::current()->RunUntilIdle();
     EXPECT_EQ(CaptivePortalService::STATE_CHECKING_FOR_PORTAL,
               service()->state());
     ASSERT_TRUE(FetchingURL());
     EXPECT_FALSE(TimerRunning());
 
-    net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
-    if (net_error != net::OK) {
-      EXPECT_FALSE(response_headers);
-      fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                                net_error));
-    } else {
-      fetcher->set_response_code(status_code);
-      if (response_headers) {
-        scoped_refptr<net::HttpResponseHeaders> headers(
-            CreateResponseHeaders(response_headers));
-        // Sanity check.
-        EXPECT_EQ(status_code, headers->response_code());
-        fetcher->set_response_headers(headers);
-      }
-    }
-
-    OnURLFetchComplete(fetcher);
+    CompleteURLFetch(net_error, status_code, response_headers);
 
     EXPECT_FALSE(FetchingURL());
     EXPECT_FALSE(TimerRunning());
     EXPECT_EQ(1, observer.num_results_received());
     EXPECT_EQ(expected_result, observer.captive_portal_result());
   }
 
   // Runs a test when the captive portal service is disabled.
   void RunDisabledTest(int expected_delay_secs) {
     base::TimeDelta expected_delay =
@@ skipping 176 matching lines @@
   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(CaptivePortalService::SKIP_OS_CHECK_FOR_TESTING);
   CaptivePortalObserver observer(profile(), service());
 
   // Needed to create the URLFetcher, even if it never returns any results.
-  net::TestURLFetcherFactory factory;
   service()->DetectCaptivePortal();
 
   MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
 
   EnableCaptivePortalDetectionPreference(false);
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
   EXPECT_EQ(0, observer.num_results_received());
 
   MessageLoop::current()->RunUntilIdle();
 
   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(CaptivePortalService::SKIP_OS_CHECK_FOR_TESTING);
   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());
 
   EnableCaptivePortalDetectionPreference(false);
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
   EXPECT_EQ(0, observer.num_results_received());
 
@@ skipping 12 matching lines @@
   Initialize(CaptivePortalService::SKIP_OS_CHECK_FOR_TESTING);
 
   EnableCaptivePortalDetectionPreference(false);
   RunDisabledTest(0);
 
   CaptivePortalObserver observer(profile(), service());
   service()->DetectCaptivePortal();
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
 
-  net::TestURLFetcherFactory factory;
-
   EnableCaptivePortalDetectionPreference(true);
   EXPECT_FALSE(FetchingURL());
   EXPECT_TRUE(TimerRunning());
 
   MessageLoop::current()->RunUntilIdle();
   ASSERT_TRUE(FetchingURL());
   EXPECT_FALSE(TimerRunning());
 
-  net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
-  fetcher->set_response_code(200);
-  OnURLFetchComplete(fetcher);
+  CompleteURLFetch(net::OK, 200, NULL);
   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 for browser tests works as expected.
 TEST_F(CaptivePortalServiceTest, CaptivePortalDisableForTests) {
   Initialize(CaptivePortalService::DISABLED_FOR_TESTING);
@@ skipping 60 matching lines @@
 
   RunTest(RESULT_NO_RESPONSE,
           net::OK,
           503,
           0,
           "HTTP/1.1 503 OK\nRetry-After: Tue, 17 Apr 2012 18:02:51 GMT\n\n");
   EXPECT_EQ(base::TimeDelta::FromSeconds(51), GetTimeUntilNextRequest());
 }
 
 }  // namespace captive_portal