Update entry page type to include error pages when appropriate.

chrome/browser/captive_portal/captive_portal_tab_helper_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/captive_portal/captive_portal_tab_helper.h"
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/captive_portal/captive_portal_service.h"
 #include "chrome/browser/captive_portal/captive_portal_tab_reloader.h"
@@ skipping 77 matching lines @@
   void SimulateSuccess(const GURL& url,
                        content::RenderViewHost* render_view_host) {
     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsSecure())).Times(1);
     tab_helper().DidStartProvisionalLoadForFrame(
         render_view_host->GetMainFrame(), url, false, false);
 
     EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
     tab_helper().DidCommitProvisionalLoadForFrame(
         render_view_host->GetMainFrame(),
         url,
+        false,  // url_is_unreachable
         ui::PAGE_TRANSITION_LINK);
   }
 
   // Simulates a connection timeout while requesting |url|.
   void SimulateTimeout(const GURL& url,
                        content::RenderViewHost* render_view_host) {
     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsSecure())).Times(1);
     tab_helper().DidStartProvisionalLoadForFrame(
         render_view_host->GetMainFrame(), url, false, false);
 
     tab_helper().DidFailProvisionalLoad(render_view_host->GetMainFrame(),
                                         url,
                                         net::ERR_TIMED_OUT,
                                         base::string16());
 
     // Provisional load starts for the error page.
     tab_helper().DidStartProvisionalLoadForFrame(
         render_view_host->GetMainFrame(), GURL(kErrorPageUrl), true, false);
 
     EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_TIMED_OUT)).Times(1);
     tab_helper().DidCommitProvisionalLoadForFrame(
         render_view_host->GetMainFrame(),
         GURL(kErrorPageUrl),
+        false,  // url_is_unreachable
         ui::PAGE_TRANSITION_LINK);
   }
 
   // Simulates an abort while requesting |url|.
   void SimulateAbort(const GURL& url,
                      content::RenderViewHost* render_view_host,
                      NavigationType navigation_type) {
     EXPECT_CALL(mock_reloader(), OnLoadStart(url.SchemeIsSecure())).Times(1);
     tab_helper().DidStartProvisionalLoadForFrame(
         render_view_host->GetMainFrame(), url, false, false);
@@ skipping 129 matching lines @@
   SimulateTimeout(GURL(kHttpUrl), render_view_host1());
 
   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
   // Provisional load starts for the error page.
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), GURL(kErrorPageUrl), true, false);
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
                                                 GURL(kErrorPageUrl),
+                                                false,  // url_is_unreachable
                                                 ui::PAGE_TRANSITION_LINK);
   tab_helper().DidStopLoading(render_view_host1());
 }
 
 TEST_F(CaptivePortalTabHelperTest, HttpsSuccess) {
   SimulateSuccess(GURL(kHttpsUrl), render_view_host1());
   tab_helper().DidStopLoading(render_view_host1());
   EXPECT_FALSE(tab_helper().IsLoginTab());
 }
 
@@ skipping 80 matching lines @@
                                       base::string16());
 
   // The provisional load starts for the error page for the cross-process
   // navigation.
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame2(), GURL(kErrorPageUrl), true, false);
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_FAILED)).Times(1);
   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame2(),
                                                 GURL(kErrorPageUrl),
+                                                false,  // url_is_unreachable
                                                 ui::PAGE_TRANSITION_TYPED);
 }
 
 // Similar to the above test, except the original RenderViewHost manages to
 // commit before its navigation is aborted.
 TEST_F(CaptivePortalTabHelperTest, UnexpectedCommit) {
   GURL same_site_url = GURL(kHttpUrl);
   GURL cross_process_url = GURL(kHttpsUrl2);
 
   // A same-site load for the original RenderViewHost starts.
@@ skipping 15 matching lines @@
   tab_helper().DidFailProvisionalLoad(main_render_frame2(),
                                       cross_process_url,
                                       net::ERR_FAILED,
                                       base::string16());
 
   // The same-site navigation succeeds.
   EXPECT_CALL(mock_reloader(), OnAbort()).Times(1);
   EXPECT_CALL(mock_reloader(),
               OnLoadStart(same_site_url.SchemeIsSecure())).Times(1);
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
-  tab_helper().DidCommitProvisionalLoadForFrame(
-      main_render_frame1(), same_site_url, ui::PAGE_TRANSITION_LINK);
+  tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
+                                                same_site_url,
+                                                false,  // url_is_unreachable
+                                                ui::PAGE_TRANSITION_LINK);
 }
 
 // Simulates navigations for a number of subframes, and makes sure no
 // CaptivePortalTabHelper function is called.
 TEST_F(CaptivePortalTabHelperTest, HttpsSubframe) {
   GURL url = GURL(kHttpsUrl);
 
   content::RenderFrameHostTester* render_frame_host_tester =
       content::RenderFrameHostTester::For(main_render_frame1());
   content::RenderFrameHost* subframe1 =
       render_frame_host_tester->AppendChild("subframe1");
 
   // Normal load.
   tab_helper().DidStartProvisionalLoadForFrame(subframe1, url, false, false);
-  tab_helper().DidCommitProvisionalLoadForFrame(
-      subframe1, url, ui::PAGE_TRANSITION_LINK);
+  tab_helper().DidCommitProvisionalLoadForFrame(subframe1,
+                                                url,
+                                                false,  // url_is_unreachable
+                                                ui::PAGE_TRANSITION_LINK);
 
   // Timeout.
   content::RenderFrameHost* subframe2 =
       render_frame_host_tester->AppendChild("subframe2");
   tab_helper().DidStartProvisionalLoadForFrame(subframe2, url, false, false);
   tab_helper().DidFailProvisionalLoad(
       subframe2, url, net::ERR_TIMED_OUT, base::string16());
   tab_helper().DidStartProvisionalLoadForFrame(subframe2, url, true, false);
   tab_helper().DidFailProvisionalLoad(
       subframe2, url, net::ERR_ABORTED, base::string16());
@@ skipping 28 matching lines @@
   tab_helper().DidFailProvisionalLoad(
       subframe, url, net::ERR_TIMED_OUT, base::string16());
 
   // Provisional load starts for the error pages.
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), url, true, false);
   tab_helper().DidStartProvisionalLoadForFrame(subframe, url, true, false);
 
   // Error page load finishes.
   tab_helper().DidCommitProvisionalLoadForFrame(
-      subframe, url, ui::PAGE_TRANSITION_AUTO_SUBFRAME);
+      subframe,
+      url,
+      false,  // url_is_unreachable
+      ui::PAGE_TRANSITION_AUTO_SUBFRAME);
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_UNEXPECTED)).Times(1);
-  tab_helper().DidCommitProvisionalLoadForFrame(
-      main_render_frame1(), url, ui::PAGE_TRANSITION_LINK);
+  tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
+                                                url,
+                                                false,  // url_is_unreachable
+                                                ui::PAGE_TRANSITION_LINK);
 }
 
 // Simulates an HTTP to HTTPS redirect, which then times out.
 TEST_F(CaptivePortalTabHelperTest, HttpToHttpsRedirectTimeout) {
   GURL http_url(kHttpUrl);
   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), http_url, false, false);
 
   GURL https_url(kHttpsUrl);
   EXPECT_CALL(mock_reloader(), OnRedirect(true)).Times(1);
   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME,
              https_url,
              render_view_host1()->GetProcess()->GetID());
 
   tab_helper().DidFailProvisionalLoad(main_render_frame1(),
                                       https_url,
                                       net::ERR_TIMED_OUT,
                                       base::string16());
 
   // Provisional load starts for the error page.
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), GURL(kErrorPageUrl), true, false);
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_TIMED_OUT)).Times(1);
   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
                                                 GURL(kErrorPageUrl),
+                                                false,  // url_is_unreachable
                                                 ui::PAGE_TRANSITION_LINK);
 }
 
 // Simulates an HTTPS to HTTP redirect.
 TEST_F(CaptivePortalTabHelperTest, HttpsToHttpRedirect) {
   GURL https_url(kHttpsUrl);
   EXPECT_CALL(mock_reloader(),
               OnLoadStart(https_url.SchemeIsSecure())).Times(1);
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), https_url, false, false);
 
   GURL http_url(kHttpUrl);
   EXPECT_CALL(mock_reloader(), OnRedirect(http_url.SchemeIsSecure())).Times(1);
   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME, http_url,
              render_view_host1()->GetProcess()->GetID());
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
-  tab_helper().DidCommitProvisionalLoadForFrame(
-      main_render_frame1(), http_url, ui::PAGE_TRANSITION_LINK);
+  tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
+                                                http_url,
+                                                false,  // url_is_unreachable
+                                                ui::PAGE_TRANSITION_LINK);
 }
 
 // Simulates an HTTPS to HTTPS redirect.
 TEST_F(CaptivePortalTabHelperTest, HttpToHttpRedirect) {
   GURL http_url(kHttpUrl);
   EXPECT_CALL(mock_reloader(),
               OnLoadStart(http_url.SchemeIsSecure())).Times(1);
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), http_url, false, false);
 
   EXPECT_CALL(mock_reloader(), OnRedirect(http_url.SchemeIsSecure())).Times(1);
   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME, http_url,
              render_view_host1()->GetProcess()->GetID());
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
-  tab_helper().DidCommitProvisionalLoadForFrame(
-      main_render_frame1(), http_url, ui::PAGE_TRANSITION_LINK);
+  tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
+                                                http_url,
+                                                false /* url_is_unreachable */,
+                                                ui::PAGE_TRANSITION_LINK);
 }
 
 // Tests that a subframe redirect doesn't reset the timer to kick off a captive
 // portal probe for the main frame if the main frame request is taking too long.
 TEST_F(CaptivePortalTabHelperTest, SubframeRedirect) {
   GURL http_url(kHttpUrl);
   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), http_url, false, false);
 
   GURL https_url(kHttpsUrl);
   OnRedirect(content::RESOURCE_TYPE_SUB_FRAME,
              https_url,
              render_view_host1()->GetProcess()->GetID());
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::OK)).Times(1);
-  tab_helper().DidCommitProvisionalLoadForFrame(
-      main_render_frame1(), GURL(kErrorPageUrl), ui::PAGE_TRANSITION_LINK);
+  tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
+                                                GURL(kErrorPageUrl),
+                                                false,  // url_is_unreachable
+                                                ui::PAGE_TRANSITION_LINK);
 }
 
 // Simulates a redirect, for another RenderViewHost.
 TEST_F(CaptivePortalTabHelperTest, OtherRenderViewHostRedirect) {
   GURL http_url(kHttpUrl);
   EXPECT_CALL(mock_reloader(), OnLoadStart(false)).Times(1);
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), http_url, false, false);
 
   // Another RenderViewHost sees a redirect.  None of the reloader's functions
   // should be called.
   GURL https_url(kHttpsUrl);
   OnRedirect(content::RESOURCE_TYPE_MAIN_FRAME,
              https_url,
              render_view_host2()->GetProcess()->GetID());
 
   tab_helper().DidFailProvisionalLoad(main_render_frame1(),
                                       https_url,
                                       net::ERR_TIMED_OUT,
                                       base::string16());
 
   // Provisional load starts for the error page.
   tab_helper().DidStartProvisionalLoadForFrame(
       main_render_frame1(), GURL(kErrorPageUrl), true, false);
 
   EXPECT_CALL(mock_reloader(), OnLoadCommitted(net::ERR_TIMED_OUT)).Times(1);
   tab_helper().DidCommitProvisionalLoadForFrame(main_render_frame1(),
                                                 GURL(kErrorPageUrl),
+                                                false,  // url_is_unreachable
                                                 ui::PAGE_TRANSITION_LINK);
 }
 
 TEST_F(CaptivePortalTabHelperTest, LoginTabLogin) {
   EXPECT_FALSE(tab_helper().IsLoginTab());
   SetIsLoginTab();
   EXPECT_TRUE(tab_helper().IsLoginTab());
 
   ObservePortalResult(captive_portal::RESULT_INTERNET_CONNECTED,
                       captive_portal::RESULT_INTERNET_CONNECTED);
@@ skipping 38 matching lines @@
   EXPECT_FALSE(tab_helper().IsLoginTab());
 
   ObservePortalResult(captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL,
                       captive_portal::RESULT_NO_RESPONSE);
   EXPECT_FALSE(tab_helper().IsLoginTab());
 
   ObservePortalResult(captive_portal::RESULT_NO_RESPONSE,
                       captive_portal::RESULT_INTERNET_CONNECTED);
   EXPECT_FALSE(tab_helper().IsLoginTab());
 }