chrome/browser/captive_portal/captive_portal_tab_reloader_unittest.cc

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