chrome/browser/captive_portal/captive_portal_tab_helper_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_helper.h"
   6
   7 #include "base/callback.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "chrome/browser/captive_portal/captive_portal_service.h"
  10 #include "chrome/browser/captive_portal/captive_portal_tab_reloader.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  13 #include "content/public/browser/notification_details.h"
  14 #include "content/public/browser/notification_service.h"
  15 #include "content/public/browser/notification_source.h"
  16 #include "content/public/browser/notification_types.h"
  17 #include "content/public/browser/render_view_host.h"
  18 #include "content/public/browser/render_process_host.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/test/test_renderer_host.h"
  21 #include "net/base/net_errors.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 using captive_portal::CaptivePortalResult;
  26 using content::ResourceType;
  27
  28 namespace {
  29
  30 const char* const kHttpUrl = "http://whatever.com/";
  31 const char* const kHttpsUrl = "https://whatever.com/";
  32
  33 // Used for cross-process navigations.  Shouldn't actually matter whether this
  34 // is different from kHttpsUrl, but best to keep things consistent.
  35 const char* const kHttpsUrl2 = "https://cross_process.com/";
  36
  37 // Error pages use a "data:" URL.  Shouldn't actually matter what this is.
  38 const char* const kErrorPageUrl = "data:blah";
  39
  40 // Some navigations behave differently depending on if they're cross-process
  41 // or not.
  42 enum NavigationType {
  43   kSameProcess,
  44   kCrossProcess,
  45 };
  46
  47 }  // namespace
  48
  49 class MockCaptivePortalTabReloader : public CaptivePortalTabReloader {
  50  public:
  51   MockCaptivePortalTabReloader()
  52       : CaptivePortalTabReloader(NULL, NULL, base::Callback<void()>()) {
  53   }
  54
  55   MOCK_METHOD1(OnLoadStart, void(bool));
  56   MOCK_METHOD1(OnLoadCommitted, void(int));
  57   MOCK_METHOD0(OnAbort, void());
  58   MOCK_METHOD1(OnRedirect, void(bool));
  59   MOCK_METHOD2(OnCaptivePortalResults,
  60                void(CaptivePortalResult, CaptivePortalResult));
  61 };
  62
  63 // Inherits from the ChromeRenderViewHostTestHarness to gain access to
  64 // CreateTestWebContents.  Since the tests need to micromanage order of
  65 // WebContentsObserver function calls, does not actually make sure of
  66 // the harness in any other way.
  67 class CaptivePortalTabHelperTest : public ChromeRenderViewHostTestHarness {
  68  public:
  69   CaptivePortalTabHelperTest()
  70       : tab_helper_(NULL),
  71         mock_reloader_(new testing::StrictMock<MockCaptivePortalTabReloader>) {
  72     tab_helper_.SetTabReloaderForTest(mock_reloader_);
  73   }
  74   ~CaptivePortalTabHelperTest() override {}
  75
  76   void SetUp() override {
  77     ChromeRenderViewHostTestHarness::SetUp();
  78     web_contents1_.reset(CreateTestWebContents());
  79     web_contents2_.reset(CreateTestWebContents());
  80
  81     // This will simulate the initialization of the RenderFrame in the renderer
  82     // process. This is needed because WebContents does not initialize a
  83     // RenderFrame on construction, and the tests expect one to exist.
  84     content::RenderFrameHostTester::For(main_render_frame1())
  85         ->InitializeRenderFrameIfNeeded();
  86     content::RenderFrameHostTester::For(main_render_frame2())
  87         ->InitializeRenderFrameIfNeeded();
  88   }
  89
  90   void TearDown() override {
  91     web_contents2_.reset(NULL);
  92     web_contents1_.reset(NULL);
  93     ChromeRenderViewHostTestHarness::TearDown();
  94   }
  95
  96   // Simulates a successful load of |url|.
  97   void SimulateSuccess(const GURL& url,
  98                        content::RenderViewHost* render_view_host) {
  99     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsCryptographic()))
 100         .Times(1);
 101     tab_helper().DidStartProvisionalLoadForFrame(
 102         render_view_host->GetMainFrame(), url, false, false);
 103
 104     EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
 105     tab_helper().DidCommitProvisionalLoadForFrame(
 106         render_view_host->GetMainFrame(),
 107         url,
 108         ui::PAGE_TRANSITION_LINK);
 109   }
 110
 111   // Simulates a connection timeout while requesting |url|.
 112   void SimulateTimeout(const GURL& url,
 113                        content::RenderViewHost* render_view_host) {
 114     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsCryptographic()))
 115         .Times(1);
 116     tab_helper().DidStartProvisionalLoadForFrame(
 117         render_view_host->GetMainFrame(), url, false, false);
 118
 119     tab_helper().DidFailProvisionalLoad(render_view_host->GetMainFrame(),
 120                                         url,
 121                                         net::ERR_TIMED_OUT,
 122                                         base::string16(),
 123                                         false);
 124
 125     // Provisional load starts for the error page.
 126     tab_helper().DidStartProvisionalLoadForFrame(
 127         render_view_host->GetMainFrame(), GURL(kErrorPageUrl), true, false);
 128
 129     EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_TIMED_OUT)).Times(1);
 130     tab_helper().DidCommitProvisionalLoadForFrame(
 131         render_view_host->GetMainFrame(),
 132         GURL(kErrorPageUrl),
 133         ui::PAGE_TRANSITION_LINK);
 134   }
 135
 136   // Simulates an abort while requesting |url|.
 137   void SimulateAbort(const GURL& url,
 138                      content::RenderViewHost* render_view_host,
 139                      NavigationType navigation_type) {
 140     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsCryptographic()))
 141         .Times(1);
 142     tab_helper().DidStartProvisionalLoadForFrame(
 143         render_view_host->GetMainFrame(), url, false, false);
 144
 145     EXPECT_CALL(mock_reloader(), OnAbort()).Times(1);
 146     if (navigation_type == kSameProcess) {
 147       tab_helper().DidFailProvisionalLoad(render_view_host->GetMainFrame(),
 148                                           url,
 149                                           net::ERR_ABORTED,
 150                                           base::string16(),
 151                                           false);
 152     } else {
 153       // For interrupted provisional cross-process navigations, the
 154       // RenderViewHost is destroyed without sending a DidFailProvisionalLoad
 155       // notification.
 156       tab_helper().RenderViewDeleted(render_view_host);
 157     }
 158
 159     // Make sure that above call resulted in abort, for tests that continue
 160     // after the abort.
 161     EXPECT_CALL(mock_reloader(), OnAbort()).Times(0);
 162   }
 163
 164   // Simulates an abort while loading an error page.
 165   void SimulateAbortTimeout(const GURL& url,
 166                             content::RenderViewHost* render_view_host,
 167                             NavigationType navigation_type) {
 168     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsCryptographic()))
 169         .Times(1);
 170     tab_helper().DidStartProvisionalLoadForFrame(
 171         render_view_host->GetMainFrame(), url, false, false);
 172
 173     tab_helper().DidFailProvisionalLoad(render_view_host->GetMainFrame(),
 174                                         url,
 175                                         net::ERR_TIMED_OUT,
 176                                         base::string16(),
 177                                         false);
 178
 179     // Start event for the error page.
 180     tab_helper().DidStartProvisionalLoadForFrame(
 181         render_view_host->GetMainFrame(), url, true, false);
 182
 183     EXPECT_CALL(mock_reloader(), OnAbort()).Times(1);
 184     if (navigation_type == kSameProcess) {
 185       tab_helper().DidFailProvisionalLoad(render_view_host->GetMainFrame(),
 186                                           url,
 187                                           net::ERR_ABORTED,
 188                                           base::string16(),
 189                                           false);
 190     } else {
 191       // For interrupted provisional cross-process navigations, the
 192       // RenderViewHost is destroyed without sending a DidFailProvisionalLoad
 193       // notification.
 194       tab_helper().RenderViewDeleted(render_view_host);
 195     }
 196
 197     // Make sure that above call resulted in abort, for tests that continue
 198     // after the abort.
 199     EXPECT_CALL(mock_reloader(), OnAbort()).Times(0);
 200   }
 201
 202   CaptivePortalTabHelper& tab_helper() {
 203     return tab_helper_;
 204   }
 205
 206   // Simulates a captive portal redirect by calling the Observe method.
 207   void ObservePortalResult(CaptivePortalResult previous_result,
 208                            CaptivePortalResult result) {
 209     content::Source<Profile> source_profile(NULL);
 210
 211     CaptivePortalService::Results results;
 212     results.previous_result = previous_result;
 213     results.result = result;
 214     content::Details<CaptivePortalService::Results> details_results(&results);
 215
 216     EXPECT_CALL(mock_reloader(), OnCaptivePortalResults(previous_result,
 217                                                         result)).Times(1);
 218     tab_helper().Observe(chrome::NOTIFICATION_CAPTIVE_PORTAL_CHECK_RESULT,
 219                          source_profile,
 220                          details_results);
 221   }
 222
 223   // Simulates a redirect.  Uses OnRedirect rather than Observe, for simplicity.
 224   void OnRedirect(ResourceType type, const GURL& new_url, int child_id) {
 225     tab_helper().OnRedirect(child_id, type, new_url);
 226   }
 227
 228   MockCaptivePortalTabReloader& mock_reloader() { return *mock_reloader_; }
 229
 230   void SetIsLoginTab() {
 231     tab_helper().SetIsLoginTab();
 232   }
 233
 234   content::RenderViewHost* render_view_host1() {
 235     return web_contents1_->GetRenderViewHost();
 236   }
 237
 238   content::RenderViewHost* render_view_host2() {
 239     return web_contents2_->GetRenderViewHost();
 240   }
 241
 242   content::RenderFrameHost* main_render_frame1() {
 243     return web_contents1_->GetMainFrame();
 244   }
 245
 246   content::RenderFrameHost* main_render_frame2() {
 247     return web_contents2_->GetMainFrame();
 248   }
 249
 250  private:
 251   // Only the RenderViewHosts are used.
 252   scoped_ptr<content::WebContents> web_contents1_;
 253   scoped_ptr<content::WebContents> web_contents2_;
 254
 255   CaptivePortalTabHelper tab_helper_;
 256
 257   // Owned by |tab_helper_|.
 258   testing::StrictMock<MockCaptivePortalTabReloader>* mock_reloader_;
 259
 260   DISALLOW_COPY_AND_ASSIGN(CaptivePortalTabHelperTest);
 261 };
 262
 263 TEST_F(CaptivePortalTabHelperTest, HttpSuccess) {
 264   SimulateSuccess(GURL(kHttpUrl), render_view_host1());
 265   tab_helper().DidStopLoading();
 266 }
 267
 268 TEST_F(CaptivePortalTabHelperTest, HttpTimeout) {
 269   SimulateTimeout(GURL(kHttpUrl), render_view_host1());
 270   tab_helper().DidStopLoading();
 271 }
 272
 273 // Same as above, but simulates what happens when the Link Doctor is enabled,
 274 // which adds another provisional load/commit for the error page, after the
 275 // first two.
 276 TEST_F(CaptivePortalTabHelperTest, HttpTimeoutLinkDoctor) {
 277   SimulateTimeout(GURL(kHttpUrl), render_view_host1());
 278
 279   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
 280   // Provisional load starts for the error page.
 281   tab_helper().DidStartProvisionalLoadForFrame(
 282       main_render_frame1(), GURL(kErrorPageUrl), true, false);
 283
 284   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
 285   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
 286                                                 GURL(kErrorPageUrl),
 287                                                 ui::PAGE_TRANSITION_LINK);
 288   tab_helper().DidStopLoading();
 289 }
 290
 291 TEST_F(CaptivePortalTabHelperTest, HttpsSuccess) {
 292   SimulateSuccess(GURL(kHttpsUrl), render_view_host1());
 293   tab_helper().DidStopLoading();
 294   EXPECT_FALSE(tab_helper().IsLoginTab());
 295 }
 296
 297 TEST_F(CaptivePortalTabHelperTest, HttpsTimeout) {
 298   SimulateTimeout(GURL(kHttpsUrl), render_view_host1());
 299   // Make sure no state was carried over from the timeout.
 300   SimulateSuccess(GURL(kHttpsUrl), render_view_host1());
 301   EXPECT_FALSE(tab_helper().IsLoginTab());
 302 }
 303
 304 TEST_F(CaptivePortalTabHelperTest, HttpsAbort) {
 305   SimulateAbort(GURL(kHttpsUrl), render_view_host1(), kSameProcess);
 306   // Make sure no state was carried over from the abort.
 307   SimulateSuccess(GURL(kHttpsUrl), render_view_host1());
 308   EXPECT_FALSE(tab_helper().IsLoginTab());
 309 }
 310
 311 // A cross-process navigation is aborted by a same-site navigation.
 312 TEST_F(CaptivePortalTabHelperTest, AbortCrossProcess) {
 313   SimulateAbort(GURL(kHttpsUrl2), render_view_host2(), kCrossProcess);
 314   // Make sure no state was carried over from the abort.
 315   SimulateSuccess(GURL(kHttpUrl), render_view_host1());
 316   EXPECT_FALSE(tab_helper().IsLoginTab());
 317 }
 318
 319 // Abort while there's a provisional timeout error page loading.
 320 TEST_F(CaptivePortalTabHelperTest, HttpsAbortTimeout) {
 321   SimulateAbortTimeout(GURL(kHttpsUrl), render_view_host1(), kSameProcess);
 322   // Make sure no state was carried over from the timeout or the abort.
 323   SimulateSuccess(GURL(kHttpsUrl), render_view_host1());
 324   EXPECT_FALSE(tab_helper().IsLoginTab());
 325 }
 326
 327 // Abort a cross-process navigation while there's a provisional timeout error
 328 // page loading.
 329 TEST_F(CaptivePortalTabHelperTest, AbortTimeoutCrossProcess) {
 330   SimulateAbortTimeout(GURL(kHttpsUrl2), render_view_host2(),
 331                        kCrossProcess);
 332   // Make sure no state was carried over from the timeout or the abort.
 333   SimulateSuccess(GURL(kHttpsUrl), render_view_host1());
 334   EXPECT_FALSE(tab_helper().IsLoginTab());
 335 }
 336
 337 // Opposite case from above - a same-process error page is aborted in favor of
 338 // a cross-process one.
 339 TEST_F(CaptivePortalTabHelperTest, HttpsAbortTimeoutForCrossProcess) {
 340   SimulateAbortTimeout(GURL(kHttpsUrl), render_view_host1(), kSameProcess);
 341   // Make sure no state was carried over from the timeout or the abort.
 342   SimulateSuccess(GURL(kHttpsUrl2), render_view_host2());
 343   EXPECT_FALSE(tab_helper().IsLoginTab());
 344 }
 345
 346 // A provisional same-site navigation is interrupted by a cross-process
 347 // navigation without sending an abort first.
 348 TEST_F(CaptivePortalTabHelperTest, UnexpectedProvisionalLoad) {
 349   GURL same_site_url = GURL(kHttpUrl);
 350   GURL cross_process_url = GURL(kHttpsUrl2);
 351
 352   // A same-site load for the original RenderViewHost starts.
 353   EXPECT_CALL(mock_reloader(),
 354               OnLoadStart(same_site_url.SchemeIsCryptographic())).Times(1);
 355   tab_helper().DidStartProvisionalLoadForFrame(
 356       main_render_frame1(), same_site_url, false, false);
 357
 358   // It's unexpectedly interrupted by a cross-process navigation, which starts
 359   // navigating before the old navigation cancels.  We generate an abort message
 360   // for the old navigation.
 361   EXPECT_CALL(mock_reloader(), OnAbort()).Times(1);
 362   EXPECT_CALL(mock_reloader(),
 363               OnLoadStart(cross_process_url.SchemeIsCryptographic())).Times(1);
 364   tab_helper().DidStartProvisionalLoadForFrame(
 365       main_render_frame2(), cross_process_url, false, false);
 366
 367   // The cross-process navigation fails.
 368   tab_helper().DidFailProvisionalLoad(main_render_frame2(),
 369                                       cross_process_url,
 370                                       net::ERR_FAILED,
 371                                       base::string16(),
 372                                       false);
 373
 374   // The same-site navigation finally is aborted.
 375   tab_helper().DidFailProvisionalLoad(main_render_frame1(),
 376                                       same_site_url,
 377                                       net::ERR_ABORTED,
 378                                       base::string16(),
 379                                       false);
 380
 381   // The provisional load starts for the error page for the cross-process
 382   // navigation.
 383   tab_helper().DidStartProvisionalLoadForFrame(
 384       main_render_frame2(), GURL(kErrorPageUrl), true, false);
 385
 386   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_FAILED)).Times(1);
 387   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame2(),
 388                                                 GURL(kErrorPageUrl),
 389                                                 ui::PAGE_TRANSITION_TYPED);
 390 }
 391
 392 // Similar to the above test, except the original RenderViewHost manages to
 393 // commit before its navigation is aborted.
 394 TEST_F(CaptivePortalTabHelperTest, UnexpectedCommit) {
 395   GURL same_site_url = GURL(kHttpUrl);
 396   GURL cross_process_url = GURL(kHttpsUrl2);
 397
 398   // A same-site load for the original RenderViewHost starts.
 399   EXPECT_CALL(mock_reloader(),
 400               OnLoadStart(same_site_url.SchemeIsCryptographic())).Times(1);
 401   tab_helper().DidStartProvisionalLoadForFrame(
 402       main_render_frame1(), same_site_url, false, false);
 403
 404   // It's unexpectedly interrupted by a cross-process navigation, which starts
 405   // navigating before the old navigation cancels.  We generate an abort message
 406   // for the old navigation.
 407   EXPECT_CALL(mock_reloader(), OnAbort()).Times(1);
 408   EXPECT_CALL(mock_reloader(),
 409               OnLoadStart(cross_process_url.SchemeIsCryptographic())).Times(1);
 410   tab_helper().DidStartProvisionalLoadForFrame(
 411       main_render_frame2(), cross_process_url, false, false);
 412
 413   // The cross-process navigation fails.
 414   tab_helper().DidFailProvisionalLoad(main_render_frame2(),
 415                                       cross_process_url,
 416                                       net::ERR_FAILED,
 417                                       base::string16(),
 418                                       false);
 419
 420   // The same-site navigation succeeds.
 421   EXPECT_CALL(mock_reloader(), OnAbort()).Times(1);
 422   EXPECT_CALL(mock_reloader(),
 423               OnLoadStart(same_site_url.SchemeIsCryptographic())).Times(1);
 424   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
 425   tab_helper().DidCommitProvisionalLoadForFrame(
 426       main_render_frame1(), same_site_url, ui::PAGE_TRANSITION_LINK);
 427 }
 428
 429 // Simulates navigations for a number of subframes, and makes sure no
 430 // CaptivePortalTabHelper function is called.
 431 TEST_F(CaptivePortalTabHelperTest, HttpsSubframe) {
 432   GURL url = GURL(kHttpsUrl);
 433
 434   content::RenderFrameHostTester* render_frame_host_tester =
 435       content::RenderFrameHostTester::For(main_render_frame1());
 436   content::RenderFrameHost* subframe1 =
 437       render_frame_host_tester->AppendChild("subframe1");
 438
 439   // Normal load.
 440   tab_helper().DidStartProvisionalLoadForFrame(subframe1, url, false, false);
 441   tab_helper().DidCommitProvisionalLoadForFrame(
 442       subframe1, url, ui::PAGE_TRANSITION_LINK);
 443
 444   // Timeout.
 445   content::RenderFrameHost* subframe2 =
 446       render_frame_host_tester->AppendChild("subframe2");
 447   tab_helper().DidStartProvisionalLoadForFrame(subframe2, url, false, false);
 448   tab_helper().DidFailProvisionalLoad(
 449       subframe2, url, net::ERR_TIMED_OUT, base::string16(), false);
 450   tab_helper().DidStartProvisionalLoadForFrame(subframe2, url, true, false);
 451   tab_helper().DidFailProvisionalLoad(
 452       subframe2, url, net::ERR_ABORTED, base::string16(), false);
 453
 454   // Abort.
 455   content::RenderFrameHost* subframe3 =
 456       render_frame_host_tester->AppendChild("subframe3");
 457   tab_helper().DidStartProvisionalLoadForFrame(subframe3, url, false, false);
 458   tab_helper().DidFailProvisionalLoad(
 459       subframe3, url, net::ERR_ABORTED, base::string16(), false);
 460 }
 461
 462 // Simulates a subframe erroring out at the same time as a provisional load,
 463 // but with a different error code.  Make sure the TabHelper sees the correct
 464 // error.
 465 TEST_F(CaptivePortalTabHelperTest, HttpsSubframeParallelError) {
 466   // URL used by both frames.
 467   GURL url = GURL(kHttpsUrl);
 468   content::RenderFrameHost* subframe =
 469       content::RenderFrameHostTester::For(main_render_frame1())
 470           ->AppendChild("subframe");
 471
 472   // Loads start.
 473   EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsCryptographic()))
 474       .Times(1);
 475   tab_helper().DidStartProvisionalLoadForFrame(
 476       main_render_frame1(), url, false, false);
 477   tab_helper().DidStartProvisionalLoadForFrame(subframe, url, false, false);
 478
 479   // Loads return errors.
 480   tab_helper().DidFailProvisionalLoad(
 481       main_render_frame1(), url, net::ERR_UNEXPECTED, base::string16(), false);
 482   tab_helper().DidFailProvisionalLoad(
 483       subframe, url, net::ERR_TIMED_OUT, base::string16(), false);
 484
 485   // Provisional load starts for the error pages.
 486   tab_helper().DidStartProvisionalLoadForFrame(
 487       main_render_frame1(), url, true, false);
 488   tab_helper().DidStartProvisionalLoadForFrame(subframe, url, true, false);
 489
 490   // Error page load finishes.
 491   tab_helper().DidCommitProvisionalLoadForFrame(
 492       subframe, url, ui::PAGE_TRANSITION_AUTO_SUBFRAME);
 493   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_UNEXPECTED)).Times(1);
 494   tab_helper().DidCommitProvisionalLoadForFrame(
 495       main_render_frame1(), url, ui::PAGE_TRANSITION_LINK);
 496 }
 497
 498 // Simulates an HTTP to HTTPS redirect, which then times out.
 499 TEST_F(CaptivePortalTabHelperTest, HttpToHttpsRedirectTimeout) {
 500   GURL http_url(kHttpUrl);
 501   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
 502   tab_helper().DidStartProvisionalLoadForFrame(
 503       main_render_frame1(), http_url, false, false);
 504
 505   GURL https_url(kHttpsUrl);
 506   EXPECT_CALL(mock_reloader(), OnRedirect(true)).Times(1);
 507   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME,
 508              https_url,
 509              render_view_host1()->GetProcess()->GetID());
 510
 511   tab_helper().DidFailProvisionalLoad(main_render_frame1(),
 512                                       https_url,
 513                                       net::ERR_TIMED_OUT,
 514                                       base::string16(),
 515                                       false);
 516
 517   // Provisional load starts for the error page.
 518   tab_helper().DidStartProvisionalLoadForFrame(
 519       main_render_frame1(), GURL(kErrorPageUrl), true, false);
 520
 521   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_TIMED_OUT)).Times(1);
 522   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
 523                                                 GURL(kErrorPageUrl),
 524                                                 ui::PAGE_TRANSITION_LINK);
 525 }
 526
 527 // Simulates an HTTPS to HTTP redirect.
 528 TEST_F(CaptivePortalTabHelperTest, HttpsToHttpRedirect) {
 529   GURL https_url(kHttpsUrl);
 530   EXPECT_CALL(mock_reloader(), OnLoadStart(https_url.SchemeIsCryptographic()))
 531       .Times(1);
 532   tab_helper().DidStartProvisionalLoadForFrame(
 533       main_render_frame1(), https_url, false, false);
 534
 535   GURL http_url(kHttpUrl);
 536   EXPECT_CALL(mock_reloader(), OnRedirect(http_url.SchemeIsCryptographic()))
 537       .Times(1);
 538   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME, http_url,
 539              render_view_host1()->GetProcess()->GetID());
 540
 541   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
 542   tab_helper().DidCommitProvisionalLoadForFrame(
 543       main_render_frame1(), http_url, ui::PAGE_TRANSITION_LINK);
 544 }
 545
 546 // Simulates an HTTPS to HTTPS redirect.
 547 TEST_F(CaptivePortalTabHelperTest, HttpToHttpRedirect) {
 548   GURL http_url(kHttpUrl);
 549   EXPECT_CALL(mock_reloader(), OnLoadStart(http_url.SchemeIsCryptographic()))
 550       .Times(1);
 551   tab_helper().DidStartProvisionalLoadForFrame(
 552       main_render_frame1(), http_url, false, false);
 553
 554   EXPECT_CALL(mock_reloader(), OnRedirect(http_url.SchemeIsCryptographic()))
 555       .Times(1);
 556   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME, http_url,
 557              render_view_host1()->GetProcess()->GetID());
 558
 559   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
 560   tab_helper().DidCommitProvisionalLoadForFrame(
 561       main_render_frame1(), http_url, ui::PAGE_TRANSITION_LINK);
 562 }
 563
 564 // Tests that a subframe redirect doesn't reset the timer to kick off a captive
 565 // portal probe for the main frame if the main frame request is taking too long.
 566 TEST_F(CaptivePortalTabHelperTest, SubframeRedirect) {
 567   GURL http_url(kHttpUrl);
 568   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
 569   tab_helper().DidStartProvisionalLoadForFrame(
 570       main_render_frame1(), http_url, false, false);
 571
 572   GURL https_url(kHttpsUrl);
 573   OnRedirect(content::RESOURCE_TYPE_SUB_FRAME,
 574              https_url,
 575              render_view_host1()->GetProcess()->GetID());
 576
 577   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
 578   tab_helper().DidCommitProvisionalLoadForFrame(
 579       main_render_frame1(), GURL(kErrorPageUrl), ui::PAGE_TRANSITION_LINK);
 580 }
 581
 582 // Simulates a redirect, for another RenderViewHost.
 583 TEST_F(CaptivePortalTabHelperTest, OtherRenderViewHostRedirect) {
 584   GURL http_url(kHttpUrl);
 585   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
 586   tab_helper().DidStartProvisionalLoadForFrame(
 587       main_render_frame1(), http_url, false, false);
 588
 589   // Another RenderViewHost sees a redirect.  None of the reloader's functions
 590   // should be called.
 591   GURL https_url(kHttpsUrl);
 592   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME,
 593              https_url,
 594              render_view_host2()->GetProcess()->GetID());
 595
 596   tab_helper().DidFailProvisionalLoad(main_render_frame1(),
 597                                       https_url,
 598                                       net::ERR_TIMED_OUT,
 599                                       base::string16(),
 600                                       false);
 601
 602   // Provisional load starts for the error page.
 603   tab_helper().DidStartProvisionalLoadForFrame(
 604       main_render_frame1(), GURL(kErrorPageUrl), true, false);
 605
 606   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_TIMED_OUT)).Times(1);
 607   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
 608                                                 GURL(kErrorPageUrl),
 609                                                 ui::PAGE_TRANSITION_LINK);
 610 }
 611
 612 TEST_F(CaptivePortalTabHelperTest, LoginTabLogin) {
 613   EXPECT_FALSE(tab_helper().IsLoginTab());
 614   SetIsLoginTab();
 615   EXPECT_TRUE(tab_helper().IsLoginTab());
 616
 617   ObservePortalResult(captive_portal::RESULT_INTERNET_CONNECTED,
 618                       captive_portal::RESULT_INTERNET_CONNECTED);
 619   EXPECT_FALSE(tab_helper().IsLoginTab());
 620 }
 621
 622 TEST_F(CaptivePortalTabHelperTest, LoginTabError) {
 623   EXPECT_FALSE(tab_helper().IsLoginTab());
 624
 625   SetIsLoginTab();
 626   EXPECT_TRUE(tab_helper().IsLoginTab());
 627
 628   ObservePortalResult(captive_portal::RESULT_INTERNET_CONNECTED,
 629                       captive_portal::RESULT_NO_RESPONSE);
 630   EXPECT_FALSE(tab_helper().IsLoginTab());
 631 }
 632
 633 TEST_F(CaptivePortalTabHelperTest, LoginTabMultipleResultsBeforeLogin) {
 634   EXPECT_FALSE(tab_helper().IsLoginTab());
 635
 636   SetIsLoginTab();
 637   EXPECT_TRUE(tab_helper().IsLoginTab());
 638
 639   ObservePortalResult(captive_portal::RESULT_INTERNET_CONNECTED,
 640                       captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL);
 641   EXPECT_TRUE(tab_helper().IsLoginTab());
 642
 643   ObservePortalResult(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
 644                       captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL);
 645   EXPECT_TRUE(tab_helper().IsLoginTab());
 646
 647   ObservePortalResult(captive_portal::RESULT_NO_RESPONSE,
 648                       captive_portal::RESULT_INTERNET_CONNECTED);
 649   EXPECT_FALSE(tab_helper().IsLoginTab());
 650 }
 651
 652 TEST_F(CaptivePortalTabHelperTest, NoLoginTab) {
 653   EXPECT_FALSE(tab_helper().IsLoginTab());
 654
 655   ObservePortalResult(captive_portal::RESULT_INTERNET_CONNECTED,
 656                       captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL);
 657   EXPECT_FALSE(tab_helper().IsLoginTab());
 658
 659   ObservePortalResult(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
 660                       captive_portal::RESULT_NO_RESPONSE);
 661   EXPECT_FALSE(tab_helper().IsLoginTab());
 662
 663   ObservePortalResult(captive_portal::RESULT_NO_RESPONSE,
 664                       captive_portal::RESULT_INTERNET_CONNECTED);
 665   EXPECT_FALSE(tab_helper().IsLoginTab());
 666 }