Move CaptivePortalDetector to src/components/captive_portal

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/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
-#include "chrome/browser/captive_portal/testing_utils.h"
 #include "chrome/browser/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 "components/captive_portal/captive_portal_testing_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 "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace captive_portal {
 
 namespace {
 
 // An observer watches the CaptivePortalDetector.  It tracks the last
 // received result and the total number of received results.
 class CaptivePortalObserver : public content::NotificationObserver {
  public:
   CaptivePortalObserver(Profile* profile,
                         CaptivePortalService* captive_portal_service)
       : captive_portal_result_(
             captive_portal_service->last_detection_result()),
         num_results_received_(0),
         profile_(profile),
         captive_portal_service_(captive_portal_service) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_CAPTIVE_PORTAL_CHECK_RESULT,
                    content::Source<Profile>(profile_));
   }
 
-  Result captive_portal_result() const { return captive_portal_result_; }
+  CaptivePortalResult captive_portal_result() const {
+    return captive_portal_result_;
+  }
 
   int num_results_received() const { return num_results_received_; }
 
  private:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     ASSERT_EQ(type, chrome::NOTIFICATION_CAPTIVE_PORTAL_CHECK_RESULT);
     ASSERT_EQ(profile_, content::Source<Profile>(source).ptr());
 
     CaptivePortalService::Results *results =
         content::Details<CaptivePortalService::Results>(details).ptr();
 
     EXPECT_EQ(captive_portal_result_, results->previous_result);
     EXPECT_EQ(captive_portal_service_->last_detection_result(),
               results->result);
 
     captive_portal_result_ = results->result;
     ++num_results_received_;
   }
 
-  Result captive_portal_result_;
+  CaptivePortalResult captive_portal_result_;
   int num_results_received_;
 
   Profile* profile_;
   CaptivePortalService* captive_portal_service_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptivePortalObserver);
 };
 
@@ skipping 57 matching lines @@
   // returning with the specified |net_error| and |status_code|.  If |net_error|
   // is not OK, |status_code| is ignored.  Expects the CaptivePortalService to
   // return |expected_result|.
   //
   // |expected_delay_secs| is the expected value of GetTimeUntilNextRequest().
   // The function makes sure the value is as expected, and then simulates
   // waiting for that period of time before running the test.
   //
   // If |response_headers| is non-NULL, the response will use it as headers
   // for the simulate URL request.  It must use single linefeeds as line breaks.
-  void RunTest(Result expected_result,
+  void RunTest(CaptivePortalResult expected_result,
                int net_error,
                int status_code,
                int expected_delay_secs,
                const char* response_headers) {
     base::TimeDelta expected_delay =
         base::TimeDelta::FromSeconds(expected_delay_secs);
 
     ASSERT_EQ(CaptivePortalService::STATE_IDLE, service()->state());
     ASSERT_EQ(expected_delay, GetTimeUntilNextRequest());
 
@@ skipping 42 matching lines @@
     base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(FetchingURL());
     EXPECT_FALSE(TimerRunning());
     EXPECT_EQ(1, observer.num_results_received());
     EXPECT_EQ(RESULT_INTERNET_CONNECTED, observer.captive_portal_result());
   }
 
   // Tests exponential backoff.  Prior to calling, the relevant recheck settings
   // must be set to have a minimum time of 100 seconds, with 2 checks before
   // starting exponential backoff.
-  void RunBackoffTest(Result expected_result, int net_error, int status_code) {
+  void RunBackoffTest(CaptivePortalResult expected_result,
+                      int net_error,
+                      int status_code) {
     RunTest(expected_result, net_error, status_code, 0, NULL);
     RunTest(expected_result, net_error, status_code, 0, NULL);
     RunTest(expected_result, net_error, status_code, 100, NULL);
     RunTest(expected_result, net_error, status_code, 200, NULL);
     RunTest(expected_result, net_error, status_code, 400, NULL);
     RunTest(expected_result, net_error, status_code, 800, NULL);
     RunTest(expected_result, net_error, status_code, 1600, NULL);
     RunTest(expected_result, net_error, status_code, 1600, NULL);
   }
 
@@ skipping 287 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