Home | History | Annotate | Download | only in browser 
      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 "content/browser/site_per_process_browsertest.h"
      6 
      7 #include "base/command_line.h"
      8 #include "base/strings/stringprintf.h"
      9 #include "content/browser/frame_host/cross_process_frame_connector.h"
     10 #include "content/browser/frame_host/frame_tree.h"
     11 #include "content/browser/frame_host/render_frame_proxy_host.h"
     12 #include "content/browser/frame_host/render_widget_host_view_child_frame.h"
     13 #include "content/browser/renderer_host/render_view_host_impl.h"
     14 #include "content/browser/web_contents/web_contents_impl.h"
     15 #include "content/public/browser/notification_observer.h"
     16 #include "content/public/browser/notification_service.h"
     17 #include "content/public/browser/notification_types.h"
     18 #include "content/public/browser/web_contents_observer.h"
     19 #include "content/public/common/content_switches.h"
     20 #include "content/public/test/browser_test_utils.h"
     21 #include "content/public/test/content_browser_test_utils.h"
     22 #include "content/public/test/test_utils.h"
     23 #include "content/shell/browser/shell.h"
     24 #include "content/test/content_browser_test_utils_internal.h"
     25 #include "net/dns/mock_host_resolver.h"
     26 
     27 namespace content {
     28 
     29 class SitePerProcessWebContentsObserver: public WebContentsObserver {
     30  public:
     31   explicit SitePerProcessWebContentsObserver(WebContents* web_contents)
     32       : WebContentsObserver(web_contents),
     33         navigation_succeeded_(false) {}
     34   virtual ~SitePerProcessWebContentsObserver() {}
     35 
     36   virtual void DidStartProvisionalLoadForFrame(
     37       RenderFrameHost* render_frame_host,
     38       const GURL& validated_url,
     39       bool is_error_page,
     40       bool is_iframe_srcdoc) OVERRIDE {
     41     navigation_succeeded_ = false;
     42   }
     43 
     44   virtual void DidFailProvisionalLoad(
     45       RenderFrameHost* render_frame_host,
     46       const GURL& validated_url,
     47       int error_code,
     48       const base::string16& error_description) OVERRIDE {
     49     navigation_url_ = validated_url;
     50     navigation_succeeded_ = false;
     51   }
     52 
     53   virtual void DidCommitProvisionalLoadForFrame(
     54       RenderFrameHost* render_frame_host,
     55       const GURL& url,
     56       ui::PageTransition transition_type) OVERRIDE {
     57     navigation_url_ = url;
     58     navigation_succeeded_ = true;
     59   }
     60 
     61   const GURL& navigation_url() const {
     62     return navigation_url_;
     63   }
     64 
     65   int navigation_succeeded() const { return navigation_succeeded_; }
     66 
     67  private:
     68   GURL navigation_url_;
     69   bool navigation_succeeded_;
     70 
     71   DISALLOW_COPY_AND_ASSIGN(SitePerProcessWebContentsObserver);
     72 };
     73 
     74 class RedirectNotificationObserver : public NotificationObserver {
     75  public:
     76   // Register to listen for notifications of the given type from either a
     77   // specific source, or from all sources if |source| is
     78   // NotificationService::AllSources().
     79   RedirectNotificationObserver(int notification_type,
     80                                const NotificationSource& source);
     81   virtual ~RedirectNotificationObserver();
     82 
     83   // Wait until the specified notification occurs.  If the notification was
     84   // emitted between the construction of this object and this call then it
     85   // returns immediately.
     86   void Wait();
     87 
     88   // Returns NotificationService::AllSources() if we haven't observed a
     89   // notification yet.
     90   const NotificationSource& source() const {
     91     return source_;
     92   }
     93 
     94   const NotificationDetails& details() const {
     95     return details_;
     96   }
     97 
     98   // NotificationObserver:
     99   virtual void Observe(int type,
    100                        const NotificationSource& source,
    101                        const NotificationDetails& details) OVERRIDE;
    102 
    103  private:
    104   bool seen_;
    105   bool seen_twice_;
    106   bool running_;
    107   NotificationRegistrar registrar_;
    108 
    109   NotificationSource source_;
    110   NotificationDetails details_;
    111   scoped_refptr<MessageLoopRunner> message_loop_runner_;
    112 
    113   DISALLOW_COPY_AND_ASSIGN(RedirectNotificationObserver);
    114 };
    115 
    116 RedirectNotificationObserver::RedirectNotificationObserver(
    117     int notification_type,
    118     const NotificationSource& source)
    119     : seen_(false),
    120       running_(false),
    121       source_(NotificationService::AllSources()) {
    122   registrar_.Add(this, notification_type, source);
    123 }
    124 
    125 RedirectNotificationObserver::~RedirectNotificationObserver() {}
    126 
    127 void RedirectNotificationObserver::Wait() {
    128   if (seen_ && seen_twice_)
    129     return;
    130 
    131   running_ = true;
    132   message_loop_runner_ = new MessageLoopRunner;
    133   message_loop_runner_->Run();
    134   EXPECT_TRUE(seen_);
    135 }
    136 
    137 void RedirectNotificationObserver::Observe(
    138     int type,
    139     const NotificationSource& source,
    140     const NotificationDetails& details) {
    141   source_ = source;
    142   details_ = details;
    143   seen_twice_ = seen_;
    144   seen_ = true;
    145   if (!running_)
    146     return;
    147 
    148   message_loop_runner_->Quit();
    149   running_ = false;
    150 }
    151 
    152 //
    153 // SitePerProcessBrowserTest
    154 //
    155 
    156 SitePerProcessBrowserTest::SitePerProcessBrowserTest() {
    157 };
    158 
    159 void SitePerProcessBrowserTest::StartFrameAtDataURL() {
    160   std::string data_url_script =
    161       "var iframes = document.getElementById('test');iframes.src="
    162       "'data:text/html,dataurl';";
    163   ASSERT_TRUE(ExecuteScript(shell()->web_contents(), data_url_script));
    164 }
    165 
    166 bool SitePerProcessBrowserTest::NavigateIframeToURL(Shell* window,
    167                                                     const GURL& url,
    168                                                     std::string iframe_id) {
    169   // TODO(creis): This should wait for LOAD_STOP, but cross-site subframe
    170   // navigations generate extra DidStartLoading and DidStopLoading messages.
    171   // Until we replace swappedout:// with frame proxies, we need to listen for
    172   // something else.  For now, we trigger NEW_SUBFRAME navigations and listen
    173   // for commit.
    174   std::string script = base::StringPrintf(
    175       "setTimeout(\""
    176       "var iframes = document.getElementById('%s');iframes.src='%s';"
    177       "\",0)",
    178       iframe_id.c_str(), url.spec().c_str());
    179   WindowedNotificationObserver load_observer(
    180       NOTIFICATION_NAV_ENTRY_COMMITTED,
    181       Source<NavigationController>(
    182           &window->web_contents()->GetController()));
    183   bool result = ExecuteScript(window->web_contents(), script);
    184   load_observer.Wait();
    185   return result;
    186 }
    187 
    188 void SitePerProcessBrowserTest::SetUpCommandLine(CommandLine* command_line) {
    189   command_line->AppendSwitch(switches::kSitePerProcess);
    190 };
    191 
    192 // It fails on ChromeOS and Android, so disabled while investigating.
    193 // http://crbug.com/399775
    194 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
    195 #define MAYBE_CrossSiteIframe DISABLED_CrossSiteIframe
    196 #else
    197 #define MAYBE_CrossSiteIframe CrossSiteIframe
    198 #endif
    199 IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, MAYBE_CrossSiteIframe) {
    200   host_resolver()->AddRule("*", "127.0.0.1");
    201   ASSERT_TRUE(test_server()->Start());
    202   GURL main_url(test_server()->GetURL("files/site_per_process_main.html"));
    203   NavigateToURL(shell(), main_url);
    204 
    205   // It is safe to obtain the root frame tree node here, as it doesn't change.
    206   FrameTreeNode* root =
    207       static_cast<WebContentsImpl*>(shell()->web_contents())->
    208           GetFrameTree()->root();
    209 
    210   SitePerProcessWebContentsObserver observer(shell()->web_contents());
    211 
    212   // Load same-site page into iframe.
    213   FrameTreeNode* child = root->child_at(0);
    214   GURL http_url(test_server()->GetURL("files/title1.html"));
    215   NavigateFrameToURL(child, http_url);
    216   EXPECT_EQ(http_url, observer.navigation_url());
    217   EXPECT_TRUE(observer.navigation_succeeded());
    218   {
    219     // There should be only one RenderWidgetHost when there are no
    220     // cross-process iframes.
    221     std::set<RenderWidgetHostView*> views_set =
    222         static_cast<WebContentsImpl*>(shell()->web_contents())
    223             ->GetRenderWidgetHostViewsInTree();
    224     EXPECT_EQ(1U, views_set.size());
    225   }
    226   RenderFrameProxyHost* proxy_to_parent =
    227       child->render_manager()->GetRenderFrameProxyHost(
    228           shell()->web_contents()->GetSiteInstance());
    229   EXPECT_FALSE(proxy_to_parent);
    230 
    231   // These must stay in scope with replace_host.
    232   GURL::Replacements replace_host;
    233   std::string foo_com("foo.com");
    234 
    235   // Load cross-site page into iframe.
    236   GURL cross_site_url(test_server()->GetURL("files/title2.html"));
    237   replace_host.SetHostStr(foo_com);
    238   cross_site_url = cross_site_url.ReplaceComponents(replace_host);
    239   NavigateFrameToURL(root->child_at(0), cross_site_url);
    240   EXPECT_EQ(cross_site_url, observer.navigation_url());
    241   EXPECT_TRUE(observer.navigation_succeeded());
    242 
    243   // Ensure that we have created a new process for the subframe.
    244   ASSERT_EQ(1U, root->child_count());
    245   SiteInstance* site_instance = child->current_frame_host()->GetSiteInstance();
    246   RenderViewHost* rvh = child->current_frame_host()->render_view_host();
    247   RenderProcessHost* rph = child->current_frame_host()->GetProcess();
    248   EXPECT_NE(shell()->web_contents()->GetRenderViewHost(), rvh);
    249   EXPECT_NE(shell()->web_contents()->GetSiteInstance(), site_instance);
    250   EXPECT_NE(shell()->web_contents()->GetRenderProcessHost(), rph);
    251   {
    252     // There should be now two RenderWidgetHosts, one for each process
    253     // rendering a frame.
    254     std::set<RenderWidgetHostView*> views_set =
    255         static_cast<WebContentsImpl*>(shell()->web_contents())
    256             ->GetRenderWidgetHostViewsInTree();
    257     EXPECT_EQ(2U, views_set.size());
    258   }
    259   proxy_to_parent = child->render_manager()->GetProxyToParent();
    260   EXPECT_TRUE(proxy_to_parent);
    261   EXPECT_TRUE(proxy_to_parent->cross_process_frame_connector());
    262   EXPECT_EQ(
    263       rvh->GetView(),
    264       proxy_to_parent->cross_process_frame_connector()->get_view_for_testing());
    265 
    266   // Load another cross-site page into the same iframe.
    267   cross_site_url = test_server()->GetURL("files/title3.html");
    268   std::string bar_com("bar.com");
    269   replace_host.SetHostStr(bar_com);
    270   cross_site_url = cross_site_url.ReplaceComponents(replace_host);
    271   NavigateFrameToURL(root->child_at(0), cross_site_url);
    272   EXPECT_EQ(cross_site_url, observer.navigation_url());
    273   EXPECT_TRUE(observer.navigation_succeeded());
    274 
    275   // Check again that a new process is created and is different from the
    276   // top level one and the previous one.
    277   ASSERT_EQ(1U, root->child_count());
    278   child = root->child_at(0);
    279   EXPECT_NE(shell()->web_contents()->GetRenderViewHost(),
    280             child->current_frame_host()->render_view_host());
    281   EXPECT_NE(rvh, child->current_frame_host()->render_view_host());
    282   EXPECT_NE(shell()->web_contents()->GetSiteInstance(),
    283             child->current_frame_host()->GetSiteInstance());
    284   EXPECT_NE(site_instance,
    285             child->current_frame_host()->GetSiteInstance());
    286   EXPECT_NE(shell()->web_contents()->GetRenderProcessHost(),
    287             child->current_frame_host()->GetProcess());
    288   EXPECT_NE(rph, child->current_frame_host()->GetProcess());
    289   {
    290     std::set<RenderWidgetHostView*> views_set =
    291         static_cast<WebContentsImpl*>(shell()->web_contents())
    292             ->GetRenderWidgetHostViewsInTree();
    293     EXPECT_EQ(2U, views_set.size());
    294   }
    295   EXPECT_EQ(proxy_to_parent, child->render_manager()->GetProxyToParent());
    296   EXPECT_TRUE(proxy_to_parent->cross_process_frame_connector());
    297   EXPECT_EQ(
    298       child->current_frame_host()->render_view_host()->GetView(),
    299       proxy_to_parent->cross_process_frame_connector()->get_view_for_testing());
    300 }
    301 
    302 // Crash a subframe and ensures its children are cleared from the FrameTree.
    303 // See http://crbug.com/338508.
    304 // TODO(creis): Disabled for flakiness; see http://crbug.com/405582.
    305 // TODO(creis): Enable this on Android when we can kill the process there.
    306 IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest, DISABLED_CrashSubframe) {
    307   host_resolver()->AddRule("*", "127.0.0.1");
    308   ASSERT_TRUE(test_server()->Start());
    309   GURL main_url(test_server()->GetURL("files/site_per_process_main.html"));
    310   NavigateToURL(shell(), main_url);
    311 
    312   StartFrameAtDataURL();
    313 
    314   // These must stay in scope with replace_host.
    315   GURL::Replacements replace_host;
    316   std::string foo_com("foo.com");
    317 
    318   // Load cross-site page into iframe.
    319   GURL cross_site_url(test_server()->GetURL("files/title2.html"));
    320   replace_host.SetHostStr(foo_com);
    321   cross_site_url = cross_site_url.ReplaceComponents(replace_host);
    322   EXPECT_TRUE(NavigateIframeToURL(shell(), cross_site_url, "test"));
    323 
    324   // Check the subframe process.
    325   FrameTreeNode* root =
    326       static_cast<WebContentsImpl*>(shell()->web_contents())->
    327           GetFrameTree()->root();
    328   ASSERT_EQ(1U, root->child_count());
    329   FrameTreeNode* child = root->child_at(0);
    330   EXPECT_EQ(main_url, root->current_url());
    331   EXPECT_EQ(cross_site_url, child->current_url());
    332 
    333   EXPECT_TRUE(
    334       child->current_frame_host()->render_view_host()->IsRenderViewLive());
    335   EXPECT_TRUE(child->current_frame_host()->IsRenderFrameLive());
    336 
    337   // Crash the subframe process.
    338   RenderProcessHost* root_process = root->current_frame_host()->GetProcess();
    339   RenderProcessHost* child_process = child->current_frame_host()->GetProcess();
    340   {
    341     RenderProcessHostWatcher crash_observer(
    342         child_process,
    343         RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT);
    344     base::KillProcess(child_process->GetHandle(), 0, false);
    345     crash_observer.Wait();
    346   }
    347 
    348   // Ensure that the child frame still exists but has been cleared.
    349   EXPECT_EQ(1U, root->child_count());
    350   EXPECT_EQ(main_url, root->current_url());
    351   EXPECT_EQ(GURL(), child->current_url());
    352 
    353   EXPECT_FALSE(
    354       child->current_frame_host()->render_view_host()->IsRenderViewLive());
    355   EXPECT_FALSE(child->current_frame_host()->IsRenderFrameLive());
    356   EXPECT_FALSE(child->current_frame_host()->render_frame_created_);
    357 
    358   // Now crash the top-level page to clear the child frame.
    359   {
    360     RenderProcessHostWatcher crash_observer(
    361         root_process,
    362         RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT);
    363     base::KillProcess(root_process->GetHandle(), 0, false);
    364     crash_observer.Wait();
    365   }
    366   EXPECT_EQ(0U, root->child_count());
    367   EXPECT_EQ(GURL(), root->current_url());
    368 }
    369 
    370 // TODO(nasko): Disable this test until out-of-process iframes is ready and the
    371 // security checks are back in place.
    372 // TODO(creis): Replace SpawnedTestServer with host_resolver to get test to run
    373 // on Android (http://crbug.com/187570).
    374 IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
    375                        DISABLED_CrossSiteIframeRedirectOnce) {
    376   ASSERT_TRUE(test_server()->Start());
    377   net::SpawnedTestServer https_server(
    378       net::SpawnedTestServer::TYPE_HTTPS,
    379       net::SpawnedTestServer::kLocalhost,
    380       base::FilePath(FILE_PATH_LITERAL("content/test/data")));
    381   ASSERT_TRUE(https_server.Start());
    382 
    383   GURL main_url(test_server()->GetURL("files/site_per_process_main.html"));
    384   GURL http_url(test_server()->GetURL("files/title1.html"));
    385   GURL https_url(https_server.GetURL("files/title1.html"));
    386 
    387   NavigateToURL(shell(), main_url);
    388 
    389   SitePerProcessWebContentsObserver observer(shell()->web_contents());
    390   {
    391     // Load cross-site client-redirect page into Iframe.
    392     // Should be blocked.
    393     GURL client_redirect_https_url(https_server.GetURL(
    394         "client-redirect?files/title1.html"));
    395     EXPECT_TRUE(NavigateIframeToURL(shell(),
    396                                     client_redirect_https_url, "test"));
    397     // DidFailProvisionalLoad when navigating to client_redirect_https_url.
    398     EXPECT_EQ(observer.navigation_url(), client_redirect_https_url);
    399     EXPECT_FALSE(observer.navigation_succeeded());
    400   }
    401 
    402   {
    403     // Load cross-site server-redirect page into Iframe,
    404     // which redirects to same-site page.
    405     GURL server_redirect_http_url(https_server.GetURL(
    406         "server-redirect?" + http_url.spec()));
    407     EXPECT_TRUE(NavigateIframeToURL(shell(),
    408                                     server_redirect_http_url, "test"));
    409     EXPECT_EQ(observer.navigation_url(), http_url);
    410     EXPECT_TRUE(observer.navigation_succeeded());
    411   }
    412 
    413   {
    414     // Load cross-site server-redirect page into Iframe,
    415     // which redirects to cross-site page.
    416     GURL server_redirect_http_url(https_server.GetURL(
    417         "server-redirect?files/title1.html"));
    418     EXPECT_TRUE(NavigateIframeToURL(shell(),
    419                                     server_redirect_http_url, "test"));
    420     // DidFailProvisionalLoad when navigating to https_url.
    421     EXPECT_EQ(observer.navigation_url(), https_url);
    422     EXPECT_FALSE(observer.navigation_succeeded());
    423   }
    424 
    425   {
    426     // Load same-site server-redirect page into Iframe,
    427     // which redirects to cross-site page.
    428     GURL server_redirect_http_url(test_server()->GetURL(
    429         "server-redirect?" + https_url.spec()));
    430     EXPECT_TRUE(NavigateIframeToURL(shell(),
    431                                     server_redirect_http_url, "test"));
    432 
    433     EXPECT_EQ(observer.navigation_url(), https_url);
    434     EXPECT_FALSE(observer.navigation_succeeded());
    435    }
    436 
    437   {
    438     // Load same-site client-redirect page into Iframe,
    439     // which redirects to cross-site page.
    440     GURL client_redirect_http_url(test_server()->GetURL(
    441         "client-redirect?" + https_url.spec()));
    442 
    443     RedirectNotificationObserver load_observer2(
    444         NOTIFICATION_LOAD_STOP,
    445         Source<NavigationController>(
    446             &shell()->web_contents()->GetController()));
    447 
    448     EXPECT_TRUE(NavigateIframeToURL(shell(),
    449                                     client_redirect_http_url, "test"));
    450 
    451     // Same-site Client-Redirect Page should be loaded successfully.
    452     EXPECT_EQ(observer.navigation_url(), client_redirect_http_url);
    453     EXPECT_TRUE(observer.navigation_succeeded());
    454 
    455     // Redirecting to Cross-site Page should be blocked.
    456     load_observer2.Wait();
    457     EXPECT_EQ(observer.navigation_url(), https_url);
    458     EXPECT_FALSE(observer.navigation_succeeded());
    459   }
    460 
    461   {
    462     // Load same-site server-redirect page into Iframe,
    463     // which redirects to same-site page.
    464     GURL server_redirect_http_url(test_server()->GetURL(
    465         "server-redirect?files/title1.html"));
    466     EXPECT_TRUE(NavigateIframeToURL(shell(),
    467                                     server_redirect_http_url, "test"));
    468     EXPECT_EQ(observer.navigation_url(), http_url);
    469     EXPECT_TRUE(observer.navigation_succeeded());
    470    }
    471 
    472   {
    473     // Load same-site client-redirect page into Iframe,
    474     // which redirects to same-site page.
    475     GURL client_redirect_http_url(test_server()->GetURL(
    476         "client-redirect?" + http_url.spec()));
    477     RedirectNotificationObserver load_observer2(
    478         NOTIFICATION_LOAD_STOP,
    479         Source<NavigationController>(
    480             &shell()->web_contents()->GetController()));
    481 
    482     EXPECT_TRUE(NavigateIframeToURL(shell(),
    483                                     client_redirect_http_url, "test"));
    484 
    485     // Same-site Client-Redirect Page should be loaded successfully.
    486     EXPECT_EQ(observer.navigation_url(), client_redirect_http_url);
    487     EXPECT_TRUE(observer.navigation_succeeded());
    488 
    489     // Redirecting to Same-site Page should be loaded successfully.
    490     load_observer2.Wait();
    491     EXPECT_EQ(observer.navigation_url(), http_url);
    492     EXPECT_TRUE(observer.navigation_succeeded());
    493   }
    494 }
    495 
    496 // TODO(nasko): Disable this test until out-of-process iframes is ready and the
    497 // security checks are back in place.
    498 // TODO(creis): Replace SpawnedTestServer with host_resolver to get test to run
    499 // on Android (http://crbug.com/187570).
    500 IN_PROC_BROWSER_TEST_F(SitePerProcessBrowserTest,
    501                        DISABLED_CrossSiteIframeRedirectTwice) {
    502   ASSERT_TRUE(test_server()->Start());
    503   net::SpawnedTestServer https_server(
    504       net::SpawnedTestServer::TYPE_HTTPS,
    505       net::SpawnedTestServer::kLocalhost,
    506       base::FilePath(FILE_PATH_LITERAL("content/test/data")));
    507   ASSERT_TRUE(https_server.Start());
    508 
    509   GURL main_url(test_server()->GetURL("files/site_per_process_main.html"));
    510   GURL http_url(test_server()->GetURL("files/title1.html"));
    511   GURL https_url(https_server.GetURL("files/title1.html"));
    512 
    513   NavigateToURL(shell(), main_url);
    514 
    515   SitePerProcessWebContentsObserver observer(shell()->web_contents());
    516   {
    517     // Load client-redirect page pointing to a cross-site client-redirect page,
    518     // which eventually redirects back to same-site page.
    519     GURL client_redirect_https_url(https_server.GetURL(
    520         "client-redirect?" + http_url.spec()));
    521     GURL client_redirect_http_url(test_server()->GetURL(
    522         "client-redirect?" + client_redirect_https_url.spec()));
    523 
    524     // We should wait until second client redirect get cancelled.
    525     RedirectNotificationObserver load_observer2(
    526         NOTIFICATION_LOAD_STOP,
    527         Source<NavigationController>(
    528             &shell()->web_contents()->GetController()));
    529 
    530     EXPECT_TRUE(NavigateIframeToURL(shell(), client_redirect_http_url, "test"));
    531 
    532     // DidFailProvisionalLoad when navigating to client_redirect_https_url.
    533     load_observer2.Wait();
    534     EXPECT_EQ(observer.navigation_url(), client_redirect_https_url);
    535     EXPECT_FALSE(observer.navigation_succeeded());
    536   }
    537 
    538   {
    539     // Load server-redirect page pointing to a cross-site server-redirect page,
    540     // which eventually redirect back to same-site page.
    541     GURL server_redirect_https_url(https_server.GetURL(
    542         "server-redirect?" + http_url.spec()));
    543     GURL server_redirect_http_url(test_server()->GetURL(
    544         "server-redirect?" + server_redirect_https_url.spec()));
    545     EXPECT_TRUE(NavigateIframeToURL(shell(),
    546                                     server_redirect_http_url, "test"));
    547     EXPECT_EQ(observer.navigation_url(), http_url);
    548     EXPECT_TRUE(observer.navigation_succeeded());
    549   }
    550 
    551   {
    552     // Load server-redirect page pointing to a cross-site server-redirect page,
    553     // which eventually redirects back to cross-site page.
    554     GURL server_redirect_https_url(https_server.GetURL(
    555         "server-redirect?" + https_url.spec()));
    556     GURL server_redirect_http_url(test_server()->GetURL(
    557         "server-redirect?" + server_redirect_https_url.spec()));
    558     EXPECT_TRUE(NavigateIframeToURL(shell(), server_redirect_http_url, "test"));
    559 
    560     // DidFailProvisionalLoad when navigating to https_url.
    561     EXPECT_EQ(observer.navigation_url(), https_url);
    562     EXPECT_FALSE(observer.navigation_succeeded());
    563   }
    564 
    565   {
    566     // Load server-redirect page pointing to a cross-site client-redirect page,
    567     // which eventually redirects back to same-site page.
    568     GURL client_redirect_http_url(https_server.GetURL(
    569         "client-redirect?" + http_url.spec()));
    570     GURL server_redirect_http_url(test_server()->GetURL(
    571         "server-redirect?" + client_redirect_http_url.spec()));
    572     EXPECT_TRUE(NavigateIframeToURL(shell(), server_redirect_http_url, "test"));
    573 
    574     // DidFailProvisionalLoad when navigating to client_redirect_http_url.
    575     EXPECT_EQ(observer.navigation_url(), client_redirect_http_url);
    576     EXPECT_FALSE(observer.navigation_succeeded());
    577   }
    578 }
    579 
    580 }  // namespace content
    581