Move CaptivePortalDetector to src/components/captive_portal

chrome/browser/captive_portal/captive_portal_browsertest.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 <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 35 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/http/transport_security_state.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using captive_portal::CaptivePortalDetector;

[mmenke, 2014/04/21 14:32:43]

If we're going to share the captive_portal namespace, this isn't needed.

[stevenjb, 2014/04/21 16:42:27]

Done.

 using content::BrowserThread;
 using content::URLRequestFailedJob;
 using content::URLRequestMockHTTPJob;
 using content::WebContents;
 
 namespace captive_portal {
 
 namespace {
 
 // Path of the fake login page, when using the TestServer.
@@ skipping 612 matching lines @@
  public:
   explicit CaptivePortalObserver(Profile* profile);
 
   // Runs the message loop until until at exactly |update_count| capitive portal
   // results have been received, since this creation of |this|.  Expects no
   // additional captive portal results.
   void WaitForResults(int num_results_to_wait_for);
 
   int num_results_received() const { return num_results_received_; }
 
-  Result captive_portal_result() const {
+  CaptivePortalResult captive_portal_result() const {
     return captive_portal_result_;
   }
 
  private:
   // Records results and exits the message loop, if needed.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Number of times OnPortalResult has been called since construction.
   int num_results_received_;
 
   // If WaitForResults was called, the total number of updates for which to
   // wait.  Value doesn't matter when |waiting_for_result_| is false.
   int num_results_to_wait_for_;
 
   bool waiting_for_result_;
 
   Profile* profile_;
 
   CaptivePortalService* captive_portal_service_;
 
   // Last result received.
-  Result captive_portal_result_;
+  CaptivePortalResult captive_portal_result_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptivePortalObserver);
 };
 
 CaptivePortalObserver::CaptivePortalObserver(Profile* profile)
     : num_results_received_(0),
       num_results_to_wait_for_(0),
       waiting_for_result_(false),
@@ skipping 105 matching lines @@
   // active tab will end up being navigated.  It should be 1, except for the
   // Link Doctor page, which acts like two navigations.
   void NavigateToPageExpectNoTest(Browser* browser,
                                   const GURL& url,
                                   int expected_navigations);
 
   // Navigates |browser|'s active tab to an SSL tab that takes a while to load,
   // triggering a captive portal check, which is expected to give the result
   // |expected_result|.  The page finishes loading, with a timeout, after the
   // captive portal check.
-  void SlowLoadNoCaptivePortal(Browser* browser, Result expected_result);
+  void SlowLoadNoCaptivePortal(Browser* browser,
+                               CaptivePortalResult expected_result);
 
   // Navigates |browser|'s active tab to an SSL timeout, expecting a captive
   // portal check to be triggered and return a result which will indicates
   // there's no detected captive portal.
-  void FastTimeoutNoCaptivePortal(Browser* browser, Result expected_result);
+  void FastTimeoutNoCaptivePortal(Browser* browser,
+                                  CaptivePortalResult expected_result);
 
   // Navigates the active tab to a slow loading SSL page, which will then
   // trigger a captive portal test.  The test is expected to find a captive
   // portal.  The slow loading page will continue to load after the function
   // returns, until URLRequestTimeoutOnDemandJob::FailJobs() is called,
   // at which point it will timeout.
   //
   // When |expect_login_tab| is false, no login tab is expected to be opened,
   // because one already exists, and the function returns once the captive
   // portal test is complete.
@@ skipping 190 matching lines @@
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
   EXPECT_EQ(1, browser->tab_strip_model()->count());
   EXPECT_EQ(expected_navigations, navigation_observer.num_navigations());
   EXPECT_EQ(0, NumLoadingTabs());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser, 0));
 }
 
 void CaptivePortalBrowserTest::SlowLoadNoCaptivePortal(
-    Browser* browser, Result expected_result) {
+    Browser* browser,
+    CaptivePortalResult expected_result) {
   CaptivePortalTabReloader* tab_reloader =
       GetTabReloader(browser->tab_strip_model()->GetActiveWebContents());
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
   ui_test_utils::NavigateToURLWithDisposition(browser,
                                               GURL(kMockHttpsUrl),
                                               CURRENT_TAB,
@@ skipping 18 matching lines @@
   ASSERT_EQ(1, browser->tab_strip_model()->count());
   EXPECT_EQ(1, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
   EXPECT_EQ(0, NumLoadingTabs());
 
   // Set a slow SSL load time to prevent the timer from triggering.
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromDays(1));
 }
 
 void CaptivePortalBrowserTest::FastTimeoutNoCaptivePortal(
-    Browser* browser, Result expected_result) {
+    Browser* browser,
+    CaptivePortalResult expected_result) {
   ASSERT_NE(expected_result, RESULT_BEHIND_CAPTIVE_PORTAL);
 
   // Set the load time to be large, so the timer won't trigger.  The value is
   // not restored at the end of the function.
   CaptivePortalTabReloader* tab_reloader =
       GetTabReloader(browser->tab_strip_model()->GetActiveWebContents());
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromHours(1));
 
   MultiNavigationObserver navigation_observer;
@@ skipping 1089 matching lines @@
       base::Bind(&AddHstsHost,
                  make_scoped_refptr(browser()->profile()->GetRequestContext()),
                  http_timeout_url.host()));
 
   SlowLoadBehindCaptivePortal(browser(), true, http_timeout_url, 1, 1);
   Login(browser(), 1, 0);
   FailLoadsAfterLogin(browser(), 1);
 }
 
 }  // namespace captive_portal