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::CaptivePortalResult;
 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.
 const char* const kTestServerLoginPath = "files/captive_portal/login.html";
 
 // Path of a page with an iframe that has a mock SSL timeout, when using the
 // TestServer.
 const char* const kTestServerIframeTimeoutPath =
     "files/captive_portal/iframe_timeout.html";
 
@@ skipping 605 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) {
-  ASSERT_NE(expected_result, RESULT_BEHIND_CAPTIVE_PORTAL);
+    Browser* browser,
+    CaptivePortalResult expected_result) {
+  ASSERT_NE(expected_result, captive_portal::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;
   CaptivePortalObserver portal_observer(browser->profile());
@@ skipping 100 matching lines @@
     ASSERT_EQ(initial_tab_count, tab_strip_model->count());
     EXPECT_EQ(initial_active_index, tab_strip_model->active_index());
   }
 
   // Wait for all the expect resource loads to actually start, so subsequent
   // functions can rely on them having started.
   URLRequestTimeoutOnDemandJob::WaitForJobs(initial_loading_tabs + 1);
 
   EXPECT_EQ(initial_loading_tabs + 1, NumLoadingTabs());
   EXPECT_EQ(expected_broken_tabs, NumBrokenTabs());
-  EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
+  EXPECT_EQ(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_EQ(expected_portal_checks, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser, initial_active_index));
 
   // Reset the load time to be large, so the timer won't trigger on a reload.
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromHours(1));
 }
@@ skipping 58 matching lines @@
     navigation_observer.WaitForNavigations(1);
     EXPECT_EQ(initial_active_index, tab_strip_model->active_index());
     EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
                      tab_strip_model->GetWebContentsAt(initial_active_index)));
     ASSERT_EQ(initial_tab_count, tab_strip_model->count());
     EXPECT_EQ(initial_active_index, tab_strip_model->active_index());
   }
 
   EXPECT_EQ(initial_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(expected_broken_tabs, NumBrokenTabs());
-  EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
+  EXPECT_EQ(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_EQ(1, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser, initial_active_index));
 }
 
 void CaptivePortalBrowserTest::NavigateLoginTab(Browser* browser,
                                                 int num_loading_tabs,
@@ skipping 13 matching lines @@
 
   // Do the navigation.
   content::RenderFrameHost* render_frame_host =
       tab_strip_model->GetActiveWebContents()->GetMainFrame();
   render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16("submitForm()"));
 
   portal_observer.WaitForResults(1);
   navigation_observer.WaitForNavigations(1);
 
   // Check the captive portal result.
-  EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
+  EXPECT_EQ(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_EQ(1, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
 
   // Make sure not much has changed.
   EXPECT_EQ(initial_tab_count, tab_strip_model->count());
   EXPECT_EQ(num_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(num_loading_tabs + num_timed_out_tabs, NumBrokenTabs());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser, login_tab_index));
@@ skipping 225 matching lines @@
   NavigateToPageExpectNoTest(browser(), url, 1);
 }
 
 // Check the captive portal result when the test request reports a network
 // error.  The check is triggered by a slow loading page, and the page
 // errors out only after getting a captive portal result.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, RequestFails) {
   SetUpCaptivePortalService(
       browser()->profile(),
       URLRequestFailedJob::GetMockHttpUrl(net::ERR_CONNECTION_CLOSED));
-  SlowLoadNoCaptivePortal(browser(), RESULT_NO_RESPONSE);
+  SlowLoadNoCaptivePortal(browser(), captive_portal::RESULT_NO_RESPONSE);
 }
 
 // Same as above, but for the rather unlikely case that the connection times out
 // before the timer triggers.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, RequestFailsFastTimout) {
   SetUpCaptivePortalService(
       browser()->profile(),
       URLRequestFailedJob::GetMockHttpUrl(net::ERR_CONNECTION_CLOSED));
-  FastTimeoutNoCaptivePortal(browser(), RESULT_NO_RESPONSE);
+  FastTimeoutNoCaptivePortal(browser(), captive_portal::RESULT_NO_RESPONSE);
 }
 
 // Checks the case that captive portal detection is disabled.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, Disabled) {
   EnableCaptivePortalDetection(browser()->profile(), false);
-  SlowLoadNoCaptivePortal(browser(), RESULT_INTERNET_CONNECTED);
+  SlowLoadNoCaptivePortal(browser(), captive_portal::RESULT_INTERNET_CONNECTED);
 }
 
 // Checks that we look for a captive portal on HTTPS timeouts and don't reload
 // the error tab when the captive portal probe gets a 204 response, indicating
 // there is no captive portal.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, InternetConnected) {
   // Can't just use SetBehindCaptivePortal(false), since then there wouldn't
   // be a timeout.
   ASSERT_TRUE(test_server()->Start());
   SetUpCaptivePortalService(browser()->profile(),
                             test_server()->GetURL("nocontent"));
-  SlowLoadNoCaptivePortal(browser(), RESULT_INTERNET_CONNECTED);
+  SlowLoadNoCaptivePortal(browser(), captive_portal::RESULT_INTERNET_CONNECTED);
 }
 
 // Checks that no login page is opened when the HTTP test URL redirects to an
 // SSL certificate error.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, RedirectSSLCertError) {
   // Need an HTTP TestServer to handle a dynamically created server redirect.
   ASSERT_TRUE(test_server()->Start());
 
   net::SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.server_certificate =
       net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
 
   GURL ssl_login_url = https_server.GetURL(kTestServerLoginPath);
 
   CaptivePortalService* captive_portal_service =
       CaptivePortalServiceFactory::GetForProfile(browser()->profile());
   ASSERT_TRUE(captive_portal_service);
   SetUpCaptivePortalService(
       browser()->profile(),
       test_server()->GetURL(CreateServerRedirect(ssl_login_url.spec())));
 
-  SlowLoadNoCaptivePortal(browser(), RESULT_NO_RESPONSE);
+  SlowLoadNoCaptivePortal(browser(), captive_portal::RESULT_NO_RESPONSE);
 }
 
 // A slow SSL load triggers a captive portal check.  The user logs on before
 // the SSL page times out.  We wait for the timeout and subsequent reload.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, Login) {
   // Load starts, detect captive portal and open up a login tab.
   SlowLoadBehindCaptivePortal(browser(), true);
 
   // Log in.  One loading tab, no timed out ones.
   Login(browser(), 1, 0);
@@ skipping 303 matching lines @@
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(0, portal_observer.num_results_received());
 }
 
 // Checks that navigating back to a timeout triggers captive portal detection.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, GoBackToTimeout) {
   // Disable captive portal detection so the first navigation doesn't open a
   // login tab.
   EnableCaptivePortalDetection(browser()->profile(), false);
 
-  SlowLoadNoCaptivePortal(browser(), RESULT_INTERNET_CONNECTED);
+  SlowLoadNoCaptivePortal(browser(), captive_portal::RESULT_INTERNET_CONNECTED);
 
   // Navigate to a working page.
   ui_test_utils::NavigateToURL(
       browser(), URLRequestMockHTTPJob::GetMockUrl(
                      base::FilePath(FILE_PATH_LITERAL("title2.html"))));
   ASSERT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
 
   EnableCaptivePortalDetection(browser()->profile(), true);
 
@@ skipping 10 matching lines @@
 
   // Wait for the check triggered by the broken tab and for the login tab to
   // stop loading.
   portal_observer.WaitForResults(1);
   navigation_observer.WaitForNavigations(1);
   // Make sure the request has been issued.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
 
   EXPECT_EQ(1, portal_observer.num_results_received());
   ASSERT_FALSE(CheckPending(browser()));
-  ASSERT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
+  ASSERT_EQ(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
 
   ASSERT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 1));
   ASSERT_TRUE(IsLoginTab(browser()->tab_strip_model()->GetWebContentsAt(1)));
 
   ASSERT_EQ(2, tab_strip_model->count());
   EXPECT_EQ(1, tab_strip_model->active_index());
@@ skipping 32 matching lines @@
 
   // Wait for the check triggered by the broken tab and for the login tab to
   // stop loading.
   portal_observer.WaitForResults(1);
   navigation_observer.WaitForNavigations(1);
   // Make sure the request has been issued.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
 
   ASSERT_EQ(1, portal_observer.num_results_received());
   ASSERT_FALSE(CheckPending(browser()));
-  ASSERT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
+  ASSERT_EQ(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
 
   ASSERT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 1));
   ASSERT_TRUE(IsLoginTab(tab_strip_model->GetWebContentsAt(1)));
 
   ASSERT_EQ(2, tab_strip_model->count());
   EXPECT_EQ(1, tab_strip_model->active_index());
@@ skipping 59 matching lines @@
   // Check that the only two navigated tabs were the new error tab in the
   // backround windows, and the login tab in the active window.
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
                    inactive_browser->tab_strip_model()->GetWebContentsAt(1)));
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
                    active_browser->tab_strip_model()->GetWebContentsAt(1)));
   EXPECT_EQ(0, NumLoadingTabs());
 
   // Check captive portal test results.
   portal_observer.WaitForResults(1);
-  ASSERT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
+  ASSERT_EQ(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_EQ(1, portal_observer.num_results_received());
 
   // Check the inactive browser.
   EXPECT_EQ(2, inactive_browser->tab_strip_model()->count());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(inactive_browser, 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(inactive_browser, 1));
 
@@ skipping 65 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       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