Add custom interstitial for captive portals.

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"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/captive_portal/captive_portal_service.h"
 #include "chrome/browser/captive_portal/captive_portal_service_factory.h"
 #include "chrome/browser/captive_portal/captive_portal_tab_helper.h"
 #include "chrome/browser/captive_portal/captive_portal_tab_reloader.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/interstitials/security_interstitial_page.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/interstitial_page.h"
+#include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_controller.h"
+#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/net_errors.h"
 #include "net/http/transport_security_state.h"
 #include "net/test/url_request/url_request_failed_job.h"
@@ skipping 636 matching lines @@
   }
 }
 
 // An observer for watching the CaptivePortalService.  It tracks the last
 // received result and the total number of received results.
 class CaptivePortalObserver : public content::NotificationObserver {
  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
+  // results have been received, since the 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_; }
 
   CaptivePortalResult captive_portal_result() const {
     return captive_portal_result_;
   }
 
  private:
@@ skipping 105 matching lines @@
   void EnableCaptivePortalDetection(Profile* profile, bool enabled);
 
   // Sets up the captive portal service for the given profile so that
   // all checks go to |test_url|.  Also disables all timers.
   void SetUpCaptivePortalService(Profile* profile, const GURL& test_url);
 
   // Returns true if |browser|'s profile is currently running a captive portal
   // check.
   bool CheckPending(Browser* browser);
 
+  // Returns the type of the interstitial being shown.
+  SecurityInterstitialPage::Type GetInterstitialType(
+      WebContents* contents) const;
+
   // Returns the CaptivePortalTabReloader::State of |web_contents|.
   CaptivePortalTabReloader::State GetStateOfTabReloader(
       WebContents* web_contents) const;
 
   // Returns the CaptivePortalTabReloader::State of the indicated tab.
   CaptivePortalTabReloader::State GetStateOfTabReloaderAt(Browser* browser,
                                                           int index) const;
 
   // Returns the number of tabs with the given state, across all profiles.
   int NumTabsWithState(CaptivePortalTabReloader::State state) const;
@@ skipping 113 matching lines @@
   void RunNavigateLoadingTabToTimeoutTest(Browser* browser,
                                           const GURL& starting_url,
                                           const GURL& interrupted_url,
                                           const GURL& timeout_url);
 
   // Sets the timeout used by a CaptivePortalTabReloader on slow SSL loads
   // before a captive portal check.
   void SetSlowSSLLoadTime(CaptivePortalTabReloader* tab_reloader,
                           base::TimeDelta slow_ssl_load_time);
 
+  void SetSSLErrorDisplayDelay(CaptivePortalTabHelper* tab_helper,
+                               base::TimeDelta ssl_error_delay);
+
   CaptivePortalTabReloader* GetTabReloader(WebContents* web_contents) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CaptivePortalBrowserTest);
 };
 
 CaptivePortalBrowserTest::CaptivePortalBrowserTest() {
 }
 
 void CaptivePortalBrowserTest::SetUpOnMainThread() {
@@ skipping 43 matching lines @@
 }
 
 bool CaptivePortalBrowserTest::CheckPending(Browser* browser) {
   CaptivePortalService* captive_portal_service =
       CaptivePortalServiceFactory::GetForProfile(browser->profile());
 
   return captive_portal_service->DetectionInProgress() ||
       captive_portal_service->TimerRunning();
 }
 
+SecurityInterstitialPage::Type CaptivePortalBrowserTest::GetInterstitialType(
+    WebContents* contents) const {
+  DCHECK(contents->ShowingInterstitialPage());
+  SecurityInterstitialPage* blocking_page =
+      static_cast<SecurityInterstitialPage*>(
+          contents->GetInterstitialPage()->GetDelegateForTesting());
+  DCHECK(blocking_page);
+  return blocking_page->GetTypeForTesting();
+}
+
 CaptivePortalTabReloader::State CaptivePortalBrowserTest::GetStateOfTabReloader(
     WebContents* web_contents) const {
   return GetTabReloader(web_contents)->state();
 }
 
 CaptivePortalTabReloader::State
 CaptivePortalBrowserTest::GetStateOfTabReloaderAt(Browser* browser,
                                                   int index) const {
   return GetStateOfTabReloader(
       browser->tab_strip_model()->GetWebContentsAt(index));
@@ skipping 514 matching lines @@
   // Timeout occurs, and page is automatically reloaded.
   FailLoadsAfterLogin(browser, 1);
 }
 
 void CaptivePortalBrowserTest::SetSlowSSLLoadTime(
     CaptivePortalTabReloader* tab_reloader,
     base::TimeDelta slow_ssl_load_time) {
   tab_reloader->set_slow_ssl_load_time(slow_ssl_load_time);
 }
 
+void CaptivePortalBrowserTest::SetSSLErrorDisplayDelay(
+    CaptivePortalTabHelper* tab_helper,
+    base::TimeDelta ssl_error_delay) {
+  tab_helper->SetSSLErrorDelayForTest(ssl_error_delay);
+}
+
 CaptivePortalTabReloader* CaptivePortalBrowserTest::GetTabReloader(
     WebContents* web_contents) const {
   return CaptivePortalTabHelper::FromWebContents(web_contents)->
       GetTabReloaderForTest();
 }
 
 // Make sure there's no test for a captive portal on HTTP timeouts.  This will
 // also trigger the link doctor page, which results in the load of a second
 // error page.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, HttpTimeout) {
@@ skipping 139 matching lines @@
 }
 
 // Checks the unlikely case that the tab times out before the timer triggers.
 // This most likely won't happen, but should still work:
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, LoginFastTimeout) {
   FastTimeoutBehindCaptivePortal(browser(), true);
   Login(browser(), 0, 1);
 }
 
 // A cert error triggers a captive portal check and results in opening a login
+// tab.
+IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest,
+                       ShowCaptivePortalInterstitialOnCertError) {
+  net::SpawnedTestServer::SSLOptions https_options;
+  https_options.server_certificate =
+      net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
+  net::SpawnedTestServer https_server(
+      net::SpawnedTestServer::TYPE_HTTPS, https_options,
+      base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+  ASSERT_TRUE(https_server.Start());
+
+  // Set SSL interstitial delay long enough so that a captive portal result
+  // is guaranteed to arrive during this window, and a captive portal
+  // error page is displayed instead of an SSL interstitial.
+  TabStripModel* tab_strip_model = browser()->tab_strip_model();
+  SetSSLErrorDisplayDelay(
+      CaptivePortalTabHelper::FromWebContents(
+          tab_strip_model->GetActiveWebContents()),
+          base::TimeDelta::FromHours(1));
+
+  content::WebContents* web_contents = tab_strip_model->GetActiveWebContents();
+  // The path does not matter.
+  GURL cert_error_url = https_server.GetURL(kTestServerLoginPath);
+  // The interstitial should trigger a captive portal check when it opens, just
+  // like navigating to kMockHttpsQuickTimeoutUrl.
+  FastErrorBehindCaptivePortal(browser(), true, cert_error_url);
+
+  EXPECT_EQ(SecurityInterstitialPage::CAPTIVE_PORTAL,
+            GetInterstitialType(web_contents));

[mmenke, 2014/11/10 17:32:08]

Should switch back to having web_contents active, and simulate a click on the
button, which should us back to having the same login tab open as before.

Should also then login, like the next test does (Could make that a different
test, if you want, but I'd like to see us login with both SSL interstitials
showing - shouldn't matter, but I'm paranoid).

[meacer, 2014/11/25 01:39:51]

Done.

+}
+
+// A cert error triggers a captive portal check and results in opening a login
 // tab.  The user then logs in and the page with the error is reloaded.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, SSLCertErrorLogin) {
   // Need an HTTP TestServer to handle a dynamically created server redirect.
   ASSERT_TRUE(test_server()->Start());
 
   net::SpawnedTestServer::SSLOptions https_options;
   https_options.server_certificate =
       net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS, https_options,
       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
 
+  // Set SSL interstitial delay to zero so that a captive portal result can not
+  // arrive during this window, so an SSL interstitial is displayed instead
+  // of a captive portal error page.

[mmenke, 2014/11/10 17:32:08]

This is racy.  We depend on the captive portal check triggered by
CaptivePortalTabReloader to make it to the IO thread and back to the
CaptivePortalTabReloader UI thread only after a message posted from the UI
thread to the UI thread completes.  That second message is posted only after the
tab reloader starts the portal check, so this is actually a race.

So...How to fix it?  I suggest waiting until the interstitial shows, and only
then triggering the captive portal probe result.

[meacer, 2014/11/14 00:30:25]

The probes are triggered automatically from SSLErrorHandler. Since I can't
access SSLErrorHandler from here, it's not clear to me how I can trigger the
probe result after the interstitial.

WDYT about making SSLErrorHandler a tab helper, so that it can be accessed from
here? That'll also fix the layering violation since I won't need to call into
CaptivePortalTabHelper to set the ssl interstitial display delay.

[meacer, 2014/11/14 01:51:24]

I'm also not sure I understand the race here. What's the second message you are
referring to?

[mmenke, 2014/11/14 15:28:55]

The timer - you tell it to trigger instantly, but at that point, you've already
tried to trigger the captive portal probe, so it may have already completed and
posted a result back to the UI thread before you start the 0-second timer.

You could just flip the order - call Handle() before triggering the probe, but
that seems extremely regression prone it me, and since it would be a flaky
regression, I think we need something more robust.

[mmenke, 2014/11/14 15:28:55]

I'm not sure if that fixes the race.

I had been thinking this test fixture allowed us to control when the captive
portal result came in, but it looks like it doesn't - would need a little work.

[meacer, 2014/11/25 01:39:51]

Added a flag to tab reloader to enable/disable portal checks on SSL errors. It
now disables portal check until an interstitial is displayed and then fires one
once there is an interstitial.

+  TabStripModel* tab_strip_model = browser()->tab_strip_model();
+  WebContents* broken_tab_contents = tab_strip_model->GetActiveWebContents();
+  SetSSLErrorDisplayDelay(
+      CaptivePortalTabHelper::FromWebContents(broken_tab_contents),
+      base::TimeDelta());
+
   // The path does not matter.
   GURL cert_error_url = https_server.GetURL(kTestServerLoginPath);
   // The interstitial should trigger a captive portal check when it opens, just
   // like navigating to kMockHttpsQuickTimeoutUrl.
   FastErrorBehindCaptivePortal(browser(), true, cert_error_url);
 
+  EXPECT_EQ(SecurityInterstitialPage::SSL,
+            GetInterstitialType(broken_tab_contents));
+
   // Simulate logging in.  Can't use Login() because the interstitial tab looks
   // like a cross between a hung tab (Load was never committed) and a tab at an
   // error page (The load was stopped).
   URLRequestMockCaptivePortalJobFactory::SetBehindCaptivePortal(false);
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser()->profile());
 
-  TabStripModel* tab_strip_model = browser()->tab_strip_model();
   content::RenderFrameHost* render_frame_host =
       tab_strip_model->GetActiveWebContents()->GetMainFrame();
   render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16("submitForm()"));
 
   // The captive portal tab navigation will trigger a captive portal check,
   // and reloading the original tab will bring up the interstitial page again,
   // triggering a second captive portal check.
   portal_observer.WaitForResults(2);
 
   // Wait for both tabs to finish loading.
@@ skipping 460 matching lines @@
   URLRequestFailedJob::GetMockHttpUrl(net::ERR_CONNECTION_TIMED_OUT);
   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);
 }

[mmenke, 2014/11/10 17:32:08]

Think we have a new error case that needs to be tested now.

A slow SSL load starts.  The reloader triggers a captive portal check, finds a
captive portal.  The SSL finally interstitial commits, triggers another captive
portal check.

The second captive portal check finds no captive portal.  The reloader triggers
a reload at the same time the error page handler tries to show an interstitial. 
We need to make sure the reload happens successfully.