Home | History | Annotate | Download | only in captive_portal 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/captive_portal/captive_portal_tab_reloader.h"
      6 
      7 #include "base/callback.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "chrome/browser/captive_portal/captive_portal_service.h"
     10 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
     11 #include "content/public/browser/browser_thread.h"
     12 #include "content/public/browser/interstitial_page.h"
     13 #include "content/public/browser/interstitial_page_delegate.h"
     14 #include "content/public/browser/web_contents.h"
     15 #include "net/base/net_errors.h"
     16 #include "net/cert/cert_status_flags.h"
     17 #include "net/ssl/ssl_info.h"
     18 #include "testing/gmock/include/gmock/gmock.h"
     19 #include "testing/gtest/include/gtest/gtest.h"
     20 #include "url/gurl.h"
     21 
     22 namespace captive_portal {
     23 
     24 // Used for testing CaptivePortalTabReloader in isolation from the observer.
     25 // Exposes a number of private functions and mocks out others.
     26 class TestCaptivePortalTabReloader : public CaptivePortalTabReloader {
     27  public:
     28   explicit TestCaptivePortalTabReloader(content::WebContents* web_contents)
     29       : CaptivePortalTabReloader(NULL,
     30                                  web_contents,
     31                                  base::Callback<void(void)>()) {
     32   }
     33 
     34   virtual ~TestCaptivePortalTabReloader() {
     35   }
     36 
     37   bool TimerRunning() {
     38     return slow_ssl_load_timer_.IsRunning();
     39   }
     40 
     41   // The following methods are aliased so they can be publicly accessed by the
     42   // unit tests.
     43 
     44   State state() const {
     45     return CaptivePortalTabReloader::state();
     46   }
     47 
     48   void set_slow_ssl_load_time(base::TimeDelta slow_ssl_load_time) {
     49     EXPECT_FALSE(TimerRunning());
     50     CaptivePortalTabReloader::set_slow_ssl_load_time(slow_ssl_load_time);
     51   }
     52 
     53   // CaptivePortalTabReloader:
     54   MOCK_METHOD0(ReloadTab, void());
     55   MOCK_METHOD0(MaybeOpenCaptivePortalLoginTab, void());
     56   MOCK_METHOD0(CheckForCaptivePortal, void());
     57 
     58  private:
     59   DISALLOW_COPY_AND_ASSIGN(TestCaptivePortalTabReloader);
     60 };
     61 
     62 // Used to test behavior when a WebContents is showing an interstitial page.
     63 class MockInterstitialPageDelegate : public content::InterstitialPageDelegate {
     64  public:
     65   // The newly created MockInterstitialPageDelegate will be owned by the
     66   // WebContents' InterstitialPage, and cleaned up when the WebContents
     67   // destroys it.
     68   explicit MockInterstitialPageDelegate(
     69       content::WebContents* web_contents) {
     70     content::InterstitialPage* interstitial_page =
     71         content::InterstitialPage::Create(
     72             web_contents, true, GURL("http://blah"), this);
     73     interstitial_page->DontCreateViewForTesting();
     74     interstitial_page->Show();
     75   }
     76 
     77   virtual ~MockInterstitialPageDelegate() {
     78   }
     79 
     80  private:
     81   // InterstitialPageDelegate implementation:
     82   virtual std::string GetHTMLContents() OVERRIDE {
     83     return "HTML Contents";
     84   }
     85 
     86   DISALLOW_COPY_AND_ASSIGN(MockInterstitialPageDelegate);
     87 };
     88 
     89 class CaptivePortalTabReloaderTest : public ChromeRenderViewHostTestHarness {
     90  public:
     91   // testing::Test:
     92   virtual void SetUp() OVERRIDE {
     93     ChromeRenderViewHostTestHarness::SetUp();
     94     tab_reloader_.reset(new testing::StrictMock<TestCaptivePortalTabReloader>(
     95         web_contents()));
     96 
     97     // Most tests don't run the message loop, so don't use a timer for them.
     98     tab_reloader_->set_slow_ssl_load_time(base::TimeDelta());
     99   }
    100 
    101   virtual void TearDown() OVERRIDE {
    102     EXPECT_FALSE(tab_reloader().TimerRunning());
    103     tab_reloader_.reset(NULL);
    104     ChromeRenderViewHostTestHarness::TearDown();
    105   }
    106 
    107   TestCaptivePortalTabReloader& tab_reloader() { return *tab_reloader_.get(); }
    108 
    109  private:
    110   scoped_ptr<TestCaptivePortalTabReloader> tab_reloader_;
    111 };
    112 
    113 // Simulates a slow SSL load when the Internet is connected.
    114 TEST_F(CaptivePortalTabReloaderTest, InternetConnected) {
    115   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    116 
    117   tab_reloader().OnLoadStart(true);
    118   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    119             tab_reloader().state());
    120   EXPECT_TRUE(tab_reloader().TimerRunning());
    121 
    122   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    123   base::MessageLoop::current()->RunUntilIdle();
    124   EXPECT_FALSE(tab_reloader().TimerRunning());
    125   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    126             tab_reloader().state());
    127 
    128   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    129                                         RESULT_INTERNET_CONNECTED);
    130 
    131   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    132   EXPECT_FALSE(tab_reloader().TimerRunning());
    133 
    134   tab_reloader().OnLoadCommitted(net::OK);
    135   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    136 }
    137 
    138 // Simulates a slow SSL load when the Internet is connected.  In this case,
    139 // the timeout error occurs before the timer triggers.  Unlikely to happen
    140 // in practice, but best if it still works.
    141 TEST_F(CaptivePortalTabReloaderTest, InternetConnectedTimeout) {
    142   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    143 
    144   tab_reloader().OnLoadStart(true);
    145   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    146             tab_reloader().state());
    147   EXPECT_TRUE(tab_reloader().TimerRunning());
    148 
    149   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    150   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    151   EXPECT_FALSE(tab_reloader().TimerRunning());
    152   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    153             tab_reloader().state());
    154 
    155   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    156                                         RESULT_INTERNET_CONNECTED);
    157 
    158   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    159 }
    160 
    161 // Simulates a slow SSL load when captive portal checks return no response.
    162 TEST_F(CaptivePortalTabReloaderTest, NoResponse) {
    163   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    164 
    165   tab_reloader().OnLoadStart(true);
    166   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    167             tab_reloader().state());
    168   EXPECT_TRUE(tab_reloader().TimerRunning());
    169 
    170   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    171   base::MessageLoop::current()->RunUntilIdle();
    172   EXPECT_FALSE(tab_reloader().TimerRunning());
    173   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    174             tab_reloader().state());
    175 
    176   tab_reloader().OnCaptivePortalResults(RESULT_NO_RESPONSE, RESULT_NO_RESPONSE);
    177 
    178   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    179   EXPECT_FALSE(tab_reloader().TimerRunning());
    180 
    181   tab_reloader().OnLoadCommitted(net::OK);
    182   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    183 }
    184 
    185 // Simulates a slow HTTP load when behind a captive portal, that eventually.
    186 // tiems out.  Since it's HTTP, the TabReloader should do nothing.
    187 TEST_F(CaptivePortalTabReloaderTest, DoesNothingOnHttp) {
    188   tab_reloader().OnLoadStart(false);
    189   EXPECT_FALSE(tab_reloader().TimerRunning());
    190   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    191 
    192   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    193                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    194   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    195 
    196   // The user logs in.
    197   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    198                                         RESULT_INTERNET_CONNECTED);
    199   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    200 
    201   // The page times out.
    202   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    203   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    204 }
    205 
    206 // Simulate the normal login process.  The user logs in before the error page
    207 // in the original tab commits.
    208 TEST_F(CaptivePortalTabReloaderTest, Login) {
    209   tab_reloader().OnLoadStart(true);
    210 
    211   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    212   base::MessageLoop::current()->RunUntilIdle();
    213   EXPECT_FALSE(tab_reloader().TimerRunning());
    214   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    215             tab_reloader().state());
    216 
    217   // The captive portal service detects a captive portal.  The TabReloader
    218   // should try and create a new login tab in response.
    219   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    220   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    221                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    222   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    223             tab_reloader().state());
    224   EXPECT_FALSE(tab_reloader().TimerRunning());
    225 
    226   // The user logs on from another tab, and a captive portal check is triggered.
    227   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    228                                         RESULT_INTERNET_CONNECTED);
    229   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    230             tab_reloader().state());
    231 
    232   // The error page commits, which should start an asynchronous reload.
    233   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    234   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    235             tab_reloader().state());
    236 
    237   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    238   base::MessageLoop::current()->RunUntilIdle();
    239   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    240 }
    241 
    242 // Simulate the normal login process.  The user logs in after the tab finishes
    243 // loading the error page.
    244 TEST_F(CaptivePortalTabReloaderTest, LoginLate) {
    245   tab_reloader().OnLoadStart(true);
    246 
    247   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    248   base::MessageLoop::current()->RunUntilIdle();
    249   EXPECT_FALSE(tab_reloader().TimerRunning());
    250   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    251             tab_reloader().state());
    252 
    253   // The captive portal service detects a captive portal.  The TabReloader
    254   // should try and create a new login tab in response.
    255   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    256   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    257                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    258   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    259             tab_reloader().state());
    260   EXPECT_FALSE(tab_reloader().TimerRunning());
    261 
    262   // The error page commits.
    263   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    264   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    265             tab_reloader().state());
    266 
    267   // The user logs on from another tab, and a captive portal check is triggered.
    268   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    269   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    270                                         RESULT_INTERNET_CONNECTED);
    271   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    272 }
    273 
    274 // Simulate a login after the tab times out unexpectedly quickly.
    275 TEST_F(CaptivePortalTabReloaderTest, TimeoutFast) {
    276   tab_reloader().OnLoadStart(true);
    277 
    278   // The error page commits, which should trigger a captive portal check,
    279   // since the timer's still running.
    280   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    281   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    282   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    283             tab_reloader().state());
    284 
    285   // The captive portal service detects a captive portal.  The TabReloader
    286   // should try and create a new login tab in response.
    287   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    288   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    289                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    290   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    291             tab_reloader().state());
    292   EXPECT_FALSE(tab_reloader().TimerRunning());
    293 
    294   // The user logs on from another tab, and a captive portal check is triggered.
    295   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    296   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    297                                         RESULT_INTERNET_CONNECTED);
    298   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    299 }
    300 
    301 // An SSL protocol error triggers a captive portal check behind a captive
    302 // portal.  The user then logs in.
    303 TEST_F(CaptivePortalTabReloaderTest, SSLProtocolError) {
    304   tab_reloader().OnLoadStart(true);
    305 
    306   // The error page commits, which should trigger a captive portal check,
    307   // since the timer's still running.
    308   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    309   tab_reloader().OnLoadCommitted(net::ERR_SSL_PROTOCOL_ERROR);
    310   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    311             tab_reloader().state());
    312 
    313   // The captive portal service detects a captive portal.  The TabReloader
    314   // should try and create a new login tab in response.
    315   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    316   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    317                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    318   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    319             tab_reloader().state());
    320   EXPECT_FALSE(tab_reloader().TimerRunning());
    321 
    322   // The user logs on from another tab, and a captive portal check is triggered.
    323   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    324   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    325                                         RESULT_INTERNET_CONNECTED);
    326   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    327 }
    328 
    329 // An SSL protocol error triggers a captive portal check behind a captive
    330 // portal.  The user logs in before the results from the captive portal check
    331 // completes.
    332 TEST_F(CaptivePortalTabReloaderTest, SSLProtocolErrorFastLogin) {
    333   tab_reloader().OnLoadStart(true);
    334 
    335   // The error page commits, which should trigger a captive portal check,
    336   // since the timer's still running.
    337   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    338   tab_reloader().OnLoadCommitted(net::ERR_SSL_PROTOCOL_ERROR);
    339   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    340             tab_reloader().state());
    341 
    342   // The user has logged in from another tab.  The tab automatically reloads.
    343   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    344   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    345                                         RESULT_INTERNET_CONNECTED);
    346   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    347 }
    348 
    349 // An SSL protocol error triggers a captive portal check behind a captive
    350 // portal.  The user logs in before the results from the captive portal check
    351 // completes.  This case is probably not too likely, but should be handled.
    352 TEST_F(CaptivePortalTabReloaderTest, SSLProtocolErrorAlreadyLoggedIn) {
    353   tab_reloader().OnLoadStart(true);
    354 
    355   // The user logs in from another tab before the tab errors out.
    356   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    357                                         RESULT_INTERNET_CONNECTED);
    358   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    359             tab_reloader().state());
    360 
    361   // The error page commits, which should trigger a reload.
    362   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    363   tab_reloader().OnLoadCommitted(net::ERR_SSL_PROTOCOL_ERROR);
    364   base::MessageLoop::current()->RunUntilIdle();
    365   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    366 }
    367 
    368 // Simulate the case that a user has already logged in before the tab receives a
    369 // captive portal result, but a RESULT_BEHIND_CAPTIVE_PORTAL was received
    370 // before the tab started loading.
    371 TEST_F(CaptivePortalTabReloaderTest, AlreadyLoggedIn) {
    372   tab_reloader().OnLoadStart(true);
    373 
    374   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    375   base::MessageLoop::current()->RunUntilIdle();
    376   EXPECT_FALSE(tab_reloader().TimerRunning());
    377   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    378             tab_reloader().state());
    379 
    380   // The user has already logged in.  Since the last result found a captive
    381   // portal, the tab will be reloaded if a timeout is committed.
    382   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    383                                         RESULT_INTERNET_CONNECTED);
    384   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    385             tab_reloader().state());
    386 
    387   // The error page commits, which should start an asynchronous reload.
    388   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    389   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    390             tab_reloader().state());
    391 
    392   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    393   base::MessageLoop::current()->RunUntilIdle();
    394   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    395 }
    396 
    397 // Same as above, except the result is received even before the timer triggers,
    398 // due to a captive portal test request from some external source, like a login
    399 // tab.
    400 TEST_F(CaptivePortalTabReloaderTest, AlreadyLoggedInBeforeTimerTriggers) {
    401   tab_reloader().OnLoadStart(true);
    402 
    403   // The user has already logged in.  Since the last result indicated there is
    404   // a captive portal, the tab will be reloaded if it times out.
    405   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    406                                         RESULT_INTERNET_CONNECTED);
    407   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    408             tab_reloader().state());
    409   EXPECT_FALSE(tab_reloader().TimerRunning());
    410 
    411   // The error page commits, which should start an asynchronous reload.
    412   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    413   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    414             tab_reloader().state());
    415 
    416   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    417   base::MessageLoop::current()->RunUntilIdle();
    418   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    419 }
    420 
    421 // Simulate the user logging in while the timer is still running.  May happen
    422 // if the tab is reloaded just before logging in on another tab.
    423 TEST_F(CaptivePortalTabReloaderTest, LoginWhileTimerRunning) {
    424   tab_reloader().OnLoadStart(true);
    425   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    426             tab_reloader().state());
    427   EXPECT_TRUE(tab_reloader().TimerRunning());
    428 
    429   // The user has already logged in.
    430   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    431                                         RESULT_INTERNET_CONNECTED);
    432   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    433             tab_reloader().state());
    434 
    435   // The error page commits, which should start an asynchronous reload.
    436   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    437   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    438             tab_reloader().state());
    439 
    440   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    441   base::MessageLoop::current()->RunUntilIdle();
    442   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    443 }
    444 
    445 // Simulate a captive portal being detected while the time is still running.
    446 // The captive portal check triggered by the timer detects the captive portal
    447 // again, and then the user logs in.
    448 TEST_F(CaptivePortalTabReloaderTest, BehindPortalResultWhileTimerRunning) {
    449   tab_reloader().OnLoadStart(true);
    450   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    451             tab_reloader().state());
    452   EXPECT_TRUE(tab_reloader().TimerRunning());
    453 
    454   // The user is behind a captive portal, but since the tab hasn't timed out,
    455   // the message is ignored.
    456   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    457                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    458   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    459             tab_reloader().state());
    460 
    461   // The rest proceeds as normal.
    462   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    463   base::MessageLoop::current()->RunUntilIdle();
    464   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    465             tab_reloader().state());
    466 
    467   // The captive portal service detects a captive portal, and this time the
    468   // tab tries to create a login tab.
    469   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    470   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    471                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    472   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    473             tab_reloader().state());
    474   EXPECT_FALSE(tab_reloader().TimerRunning());
    475 
    476   // The user logs on from another tab, and a captive portal check is triggered.
    477   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    478                                         RESULT_INTERNET_CONNECTED);
    479   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    480             tab_reloader().state());
    481 
    482   // The error page commits, which should start an asynchronous reload.
    483   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    484   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    485             tab_reloader().state());
    486 
    487   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    488   base::MessageLoop::current()->RunUntilIdle();
    489   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    490 }
    491 
    492 // The CaptivePortalService detects the user has logged in to a captive portal
    493 // while the timer is still running, but the original load succeeds, so no
    494 // reload is done.
    495 TEST_F(CaptivePortalTabReloaderTest, LogInWhileTimerRunningNoError) {
    496   tab_reloader().OnLoadStart(true);
    497   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    498             tab_reloader().state());
    499   EXPECT_TRUE(tab_reloader().TimerRunning());
    500 
    501   // The user has already logged in.
    502   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    503                                         RESULT_INTERNET_CONNECTED);
    504   EXPECT_FALSE(tab_reloader().TimerRunning());
    505   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    506             tab_reloader().state());
    507 
    508   // The page successfully commits, so no reload is triggered.
    509   tab_reloader().OnLoadCommitted(net::OK);
    510   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    511 }
    512 
    513 // Simulate the login process when there's an SSL certificate error.
    514 TEST_F(CaptivePortalTabReloaderTest, SSLCertErrorLogin) {
    515   tab_reloader().OnLoadStart(true);
    516   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    517             tab_reloader().state());
    518 
    519   // The load is interrupted by an interstitial page.  The interstitial page
    520   // is created after the TabReloader is notified.
    521   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal());
    522   net::SSLInfo ssl_info;
    523   ssl_info.SetCertError(net::CERT_STATUS_COMMON_NAME_INVALID);
    524   tab_reloader().OnSSLCertError(ssl_info);
    525   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    526             tab_reloader().state());
    527   EXPECT_FALSE(tab_reloader().TimerRunning());
    528   // The MockInterstitialPageDelegate will cleaned up by the WebContents.
    529   new MockInterstitialPageDelegate(web_contents());
    530 
    531   // Captive portal probe finds a captive portal.
    532   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    533   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    534                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    535 
    536   // The user logs in.  Since the interstitial is showing, the page should
    537   // be reloaded, despite still having a provisional load.
    538   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    539   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    540                                         RESULT_INTERNET_CONNECTED);
    541 }
    542 
    543 // Simulate an HTTP redirect to HTTPS, when the Internet is connected.
    544 TEST_F(CaptivePortalTabReloaderTest, HttpToHttpsRedirectInternetConnected) {
    545   tab_reloader().OnLoadStart(false);
    546   // There should be no captive portal check pending.
    547   base::MessageLoop::current()->RunUntilIdle();
    548 
    549   // HTTP to HTTPS redirect.
    550   tab_reloader().OnRedirect(true);
    551   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    552             tab_reloader().state());
    553   EXPECT_TRUE(tab_reloader().TimerRunning());
    554 
    555   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    556   base::MessageLoop::current()->RunUntilIdle();
    557   EXPECT_FALSE(tab_reloader().TimerRunning());
    558   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    559             tab_reloader().state());
    560 
    561   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    562                                         RESULT_INTERNET_CONNECTED);
    563 
    564   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    565   EXPECT_FALSE(tab_reloader().TimerRunning());
    566 
    567   tab_reloader().OnLoadCommitted(net::OK);
    568   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    569 }
    570 
    571 // Simulate an HTTP redirect to HTTPS and subsequent Login, when the user logs
    572 // in before the original page commits.
    573 TEST_F(CaptivePortalTabReloaderTest, HttpToHttpsRedirectLogin) {
    574   tab_reloader().OnLoadStart(false);
    575   // There should be no captive portal check pending.
    576   base::MessageLoop::current()->RunUntilIdle();
    577 
    578   // HTTP to HTTPS redirect.
    579   tab_reloader().OnRedirect(true);
    580   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    581             tab_reloader().state());
    582 
    583   EXPECT_CALL(tab_reloader(), CheckForCaptivePortal()).Times(1);
    584   base::MessageLoop::current()->RunUntilIdle();
    585   EXPECT_FALSE(tab_reloader().TimerRunning());
    586   EXPECT_EQ(CaptivePortalTabReloader::STATE_MAYBE_BROKEN_BY_PORTAL,
    587             tab_reloader().state());
    588 
    589   // The captive portal service detects a captive portal.  The TabReloader
    590   // should try and create a new login tab in response.
    591   EXPECT_CALL(tab_reloader(), MaybeOpenCaptivePortalLoginTab()).Times(1);
    592   tab_reloader().OnCaptivePortalResults(RESULT_INTERNET_CONNECTED,
    593                                         RESULT_BEHIND_CAPTIVE_PORTAL);
    594   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
    595             tab_reloader().state());
    596   EXPECT_FALSE(tab_reloader().TimerRunning());
    597 
    598   // The user logs on from another tab, and a captive portal check is triggered.
    599   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    600                                         RESULT_INTERNET_CONNECTED);
    601   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    602             tab_reloader().state());
    603 
    604   // The error page commits, which should start an asynchronous reload.
    605   tab_reloader().OnLoadCommitted(net::ERR_CONNECTION_TIMED_OUT);
    606   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
    607             tab_reloader().state());
    608 
    609   EXPECT_CALL(tab_reloader(), ReloadTab()).Times(1);
    610   base::MessageLoop::current()->RunUntilIdle();
    611   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    612 }
    613 
    614 // Simulate the case where an HTTPs page redirects to an HTTPS page, before
    615 // the timer triggers.
    616 TEST_F(CaptivePortalTabReloaderTest, HttpsToHttpRedirect) {
    617   tab_reloader().OnLoadStart(true);
    618   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    619             tab_reloader().state());
    620 
    621   tab_reloader().OnRedirect(false);
    622   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    623   EXPECT_FALSE(tab_reloader().TimerRunning());
    624 
    625   // There should be no captive portal check pending after the redirect.
    626   base::MessageLoop::current()->RunUntilIdle();
    627 
    628   // Logging in shouldn't do anything.
    629   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    630                                         RESULT_INTERNET_CONNECTED);
    631   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    632 }
    633 
    634 // Check that an HTTPS to HTTPS redirect results in no timer running.
    635 TEST_F(CaptivePortalTabReloaderTest, HttpsToHttpsRedirect) {
    636   tab_reloader().OnLoadStart(true);
    637   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    638             tab_reloader().state());
    639 
    640   tab_reloader().OnRedirect(true);
    641   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
    642             tab_reloader().state());
    643   EXPECT_FALSE(tab_reloader().TimerRunning());
    644   // Nothing should happen.
    645   base::MessageLoop::current()->RunUntilIdle();
    646 }
    647 
    648 // Check that an HTTPS to HTTP to HTTPS redirect results in no timer running.
    649 TEST_F(CaptivePortalTabReloaderTest, HttpsToHttpToHttpsRedirect) {
    650   tab_reloader().OnLoadStart(true);
    651   EXPECT_EQ(CaptivePortalTabReloader::STATE_TIMER_RUNNING,
    652             tab_reloader().state());
    653 
    654   tab_reloader().OnRedirect(false);
    655   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    656   EXPECT_FALSE(tab_reloader().TimerRunning());
    657 
    658   tab_reloader().OnRedirect(true);
    659   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
    660             tab_reloader().state());
    661   EXPECT_FALSE(tab_reloader().TimerRunning());
    662   // Nothing should happen.
    663   base::MessageLoop::current()->RunUntilIdle();
    664 }
    665 
    666 // Check that an HTTP to HTTP redirect results in the timer not running.
    667 TEST_F(CaptivePortalTabReloaderTest, HttpToHttpRedirect) {
    668   tab_reloader().OnLoadStart(false);
    669   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    670 
    671   tab_reloader().OnRedirect(false);
    672   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    673   EXPECT_FALSE(tab_reloader().TimerRunning());
    674 
    675   // There should be no captive portal check pending after the redirect.
    676   base::MessageLoop::current()->RunUntilIdle();
    677 
    678   // Logging in shouldn't do anything.
    679   tab_reloader().OnCaptivePortalResults(RESULT_BEHIND_CAPTIVE_PORTAL,
    680                                         RESULT_INTERNET_CONNECTED);
    681   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE, tab_reloader().state());
    682 }
    683 
    684 }  // namespace captive_portal
    685