Handle interface to prerenders.

chrome/browser/prerender/prerender_browsertest.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 <deque>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data_helper.h"
 #include "chrome/browser/browsing_data_remover.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_contents.h"
+#include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
 #include "chrome/browser/prerender/prerender_link_manager_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
+#include "content/public/test/test_navigation_observer.h"
 #include "grit/generated_resources.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::DevToolsClientHost;
@@ skipping 47 matching lines @@
   prerender_manager->CancelAllPrerenders();
 }
 
 // Returns true if and only if the final status is one in which the prerendered
 // page should prerender correctly. The page still may not be used.
 bool ShouldRenderPrerenderedPageCorrectly(FinalStatus status) {
   switch (status) {
     case FINAL_STATUS_USED:
     case FINAL_STATUS_WINDOW_OPENER:
     case FINAL_STATUS_APP_TERMINATING:
-    case FINAL_STATUS_FRAGMENT_MISMATCH:
     case FINAL_STATUS_CACHE_OR_HISTORY_CLEARED:
     // We'll crash the renderer after it's loaded.
     case FINAL_STATUS_RENDERER_CRASHED:
     case FINAL_STATUS_CANCELLED:
     case FINAL_STATUS_DEVTOOLS_ATTACHED:
-    case FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH:
       return true;
     default:
       return false;
   }
 }
 
 // PrerenderContents that stops the UI message loop on DidStopLoading().
 class TestPrerenderContents : public PrerenderContents {
  public:
   TestPrerenderContents(
@@ skipping 89 matching lines @@
 
   virtual void DidStopLoading() OVERRIDE {
     PrerenderContents::DidStopLoading();
     ++number_of_loads_;
     if (ShouldRenderPrerenderedPageCorrectly(expected_final_status_) &&
         number_of_loads_ == expected_number_of_loads_) {
       MessageLoopForUI::current()->Quit();
     }
   }
 
-  virtual void AddPendingPrerender(const GURL& url,
-                                   const content::Referrer& referrer,
-                                   const gfx::Size& size) OVERRIDE {
-    PrerenderContents::AddPendingPrerender(url, referrer, size);
+  virtual void AddPendingPrerender(
+      base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+      const GURL& url,
+      const content::Referrer& referrer,
+      const gfx::Size& size) OVERRIDE {
+    PrerenderContents::AddPendingPrerender(
+        weak_prerender_handle, url, referrer, size);
     if (expected_pending_prerenders_ > 0 &&
-        pending_prerender_list()->size() == expected_pending_prerenders_) {
+        pending_prerenders().size() == expected_pending_prerenders_) {
       MessageLoop::current()->Quit();
     }
   }
 
   virtual WebContents* CreateWebContents(
       content::SessionStorageNamespace* session_storage_namespace) OVERRIDE {
     WebContents* web_contents = PrerenderContents::CreateWebContents(
         session_storage_namespace);
     string16 ready_title = ASCIIToUTF16(kReadyTitle);
     if (prerender_should_wait_for_ready_title_)
       ready_title_watcher_.reset(new ui_test_utils::TitleWatcher(
           web_contents, ready_title));
     return web_contents;
   }
 
   void WaitForPrerenderToHaveReadyTitleIfRequired() {
     if (ready_title_watcher_.get()) {
       string16 ready_title = ASCIIToUTF16(kReadyTitle);
       ASSERT_EQ(ready_title, ready_title_watcher_->WaitAndGetTitle());
     }
   }
 
   // Waits until the prerender has |expected_pending_prerenders| pending
   // prerenders.
   void WaitForPendingPrerenders(size_t expected_pending_prerenders) {
-    if (pending_prerender_list()->size() < expected_pending_prerenders) {
+    if (pending_prerenders().size() < expected_pending_prerenders) {
       expected_pending_prerenders_ = expected_pending_prerenders;
       ui_test_utils::RunMessageLoop();
       expected_pending_prerenders_ = 0;
     }
 
-    EXPECT_EQ(expected_pending_prerenders, pending_prerender_list()->size());
+    EXPECT_EQ(expected_pending_prerenders, pending_prerenders().size());
+  }
+
+  bool UrlIsPending(const GURL& url) const {
+    for (std::vector<PendingPrerenderInfo>::const_iterator
+             it = pending_prerenders().begin(),
+             end = pending_prerenders().end();
+         it != end;
+         ++it) {
+      if (it->url == url && it->weak_prerender_handle) {
+        EXPECT_TRUE(IsPendingEntry(*it->weak_prerender_handle));
+        EXPECT_TRUE(it->weak_prerender_handle->IsPending());
+        return true;
+      }
+    }
+    return false;
   }
 
   // For tests that open the prerender in a new background tab, the RenderView
   // will not have been made visible when the PrerenderContents is destroyed
   // even though it is used.
   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 
   int number_of_loads() const { return number_of_loads_; }
 
+  FinalStatus expected_final_status() const { return expected_final_status_; }
+
+  bool WillQuitMessageLoopOnDestruction() const {

[mmenke, 2012/07/13 14:49:10]

nit:  quit_message_loop_on_destruction()

[gavinp, 2012/07/13 16:42:43]

Done, though I avoided that as I felt the Will helped documentation.

+    return quit_message_loop_on_destruction_;
+  }
+
  private:
   virtual void OnRenderViewHostCreated(
       RenderViewHost* new_render_view_host) OVERRIDE {
     // Used to make sure the RenderViewHost is hidden and, if used,
     // subsequently shown.
     notification_registrar().Add(
         this,
         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
         content::Source<RenderWidgetHost>(new_render_view_host));
 
@@ skipping 196 matching lines @@
 #endif
         use_https_src_server_(false),
         call_javascript_(true),
         loader_path_("files/prerender/prerender_loader.html"),
         explicitly_set_browser_(NULL) {
     EnableDOMAutomation();
   }
 
   virtual ~PrerenderBrowserTest() {}
 
+  content::SessionStorageNamespace* GetSessionStorageNamespace() const {
+    TabContents* tab_contents =
+        current_browser()->tab_strip_model()->GetActiveTabContents();
+    if (!tab_contents)
+      return NULL;
+    return tab_contents->web_contents()->GetRenderViewHost()->
+        GetSessionStorageNamespace();
+  }
+
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 #if defined(ENABLE_SAFE_BROWSING)
     SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
 #endif
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitchASCII(switches::kPrerenderMode,
                                     switches::kPrerenderModeSwitchValueEnabled);
 #if defined(OS_MACOSX)
@@ skipping 193 matching lines @@
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   void NavigateToURL(const std::string& dest_html_file) const {
     GURL dest_url = test_server()->GetURL(dest_html_file);
     NavigateToURLImpl(dest_url, CURRENT_TAB);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
-    GURL dest_url = test_server()->GetURL(html_file);
-    return (GetPrerenderManager()->FindEntry(dest_url) != NULL);
+    return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
   }
 
-  bool UrlIsInPrerenderManager(const GURL& url) {
-    return (GetPrerenderManager()->FindEntry(url) != NULL);
+  bool UrlIsInPrerenderManager(const GURL& url) const {
+    return GetPrerenderManager()->FindPrerenderData(
+        url, GetSessionStorageNamespace()) != NULL;
   }
 
-  bool UrlIsPendingInPrerenderManager(const std::string& html_file) const {
+  // This only checks to see if the URL is pending in our TestPrerenderContents.
+  bool UrlIsPending(const std::string& html_file) const {
+    TestPrerenderContents* test_prerender_contents = GetPrerenderContents();
+    if (!test_prerender_contents)
+      return false;
     GURL dest_url = test_server()->GetURL(html_file);
-    return GetPrerenderManager()->IsPendingEntry(dest_url);
+    return test_prerender_contents->UrlIsPending(dest_url);
   }
 
   void set_use_https_src(bool use_https_src_server) {
     use_https_src_server_ = use_https_src_server;
   }
 
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
@@ skipping 30 matching lines @@
     return static_cast<int>(history_list->GetSize());
   }
 
 #if defined(ENABLE_SAFE_BROWSING)
   FakeSafeBrowsingService* GetSafeBrowsingService() {
     return safe_browsing_factory_->most_recent_service();
   }
 #endif
 
   TestPrerenderContents* GetPrerenderContents() const {
+    PrerenderManager::PrerenderData* prerender_data =
+        GetPrerenderManager()->FindPrerenderData(
+            dest_url_, GetSessionStorageNamespace());
     return static_cast<TestPrerenderContents*>(
-        GetPrerenderManager()->FindEntry(dest_url_));
+        prerender_data ? prerender_data->contents() : NULL);
   }
 
   void set_loader_path(const std::string& path) {
     loader_path_ = path;
   }
 
   void set_loader_query_and_fragment(const std::string& query_and_fragment) {
     loader_query_and_fragment_ = query_and_fragment;
   }
 
@@ skipping 64 matching lines @@
     ASSERT_TRUE(prerender_contents_factory_ == NULL);
     prerender_contents_factory_ =
         new WaitForLoadPrerenderContentsFactory(
             expected_number_of_loads,
             expected_final_status_queue,
             prerender_should_wait_for_ready_title);
     prerender_manager->SetPrerenderContentsFactory(
         prerender_contents_factory_);
     FinalStatus expected_final_status = expected_final_status_queue.front();
 
+    // We construct this launch_nav_observer so that we can be certain our

[mmenke, 2012/07/13 14:49:10]

nit:  "this WindowedNotificationObserver" or "launch_nav_observer".

[gavinp, 2012/07/13 16:42:43]

Done.

+    // loader page has finished loading before continuing. This prevents
+    // ambiguous NOTIFICATION_LOAD_STOP events from making tests flaky.
+    WebContents* web_contents = chrome::GetActiveWebContents(current_browser());
+    ui_test_utils::WindowedNotificationObserver loader_nav_observer(
+        content::NOTIFICATION_LOAD_STOP,
+        content::Source<NavigationController>(
+            &web_contents->GetController()));
+
     // ui_test_utils::NavigateToURL uses its own observer and message loop.
     // Since the test needs to wait until the prerendered page has stopped
     // loading, rather than the page directly navigated to, need to
     // handle browser navigation directly.
     current_browser()->OpenURL(OpenURLParams(
         loader_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED,
         false));
 
     ui_test_utils::RunMessageLoop();
+    loader_nav_observer.Wait();

[mmenke, 2012/07/13 14:49:10]

Suggest a comment that this must be after the ui_test_utils::RunMessageLoop();
line, since otherwise the prerender's DidStopLoading event could end up exiting
the loader_nav_observer's message loop.

[gavinp, 2012/07/13 16:42:43]

Added. But is that really true? The prerender is on a different web contents, so
we're not going to get notifications from it, are we? I think what we're
guarding against here is the prerender finishing and exiting the message loop
redundantly? 

[mmenke, 2012/07/13 17:01:29]

The problem isn't that we could get its message, it's that its exit call would
mess things up.  Consider this:

load_nav_observer starts waiting.
PrerenderContents is destroyed, tries to exit message loop.
First load completes, tries to exit message loop.  (This can happen since it
uses ::Quit instead of ::QuitNow.  Order could also be reversed).
We exit message loop.
We call RunMessageLoop.
We hang forever.

Alternatively:

load_nav_observer starts waiting.
PrerenderContents is destroyed, tries to exit message loop.
We exit message loop.
loader_nav_observer notices it didn't exit the message loop.  It is sad.  :(

 
     TestPrerenderContents* prerender_contents = GetPrerenderContents();
 
     if (ShouldRenderPrerenderedPageCorrectly(expected_final_status)) {
       ASSERT_TRUE(prerender_contents != NULL);
       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
 
       if (call_javascript_ && expected_number_of_loads > 0) {
         // Wait for the prerendered page to change title to signal it is ready
         // if required.
         prerender_contents->WaitForPrerenderToHaveReadyTitleIfRequired();
 
         // Check if page behaves as expected while in prerendered state.
         bool prerender_test_result = false;
         ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
             prerender_contents->GetRenderViewHostMutable(), L"",
             L"window.domAutomationController.send(DidPrerenderPass())",
             &prerender_test_result));
         EXPECT_TRUE(prerender_test_result);
       }
     } else {
       // In the failure case, we should have removed |dest_url_| from the
       // prerender_manager.  We ignore dummy PrerenderContents (as indicated
-      // by not having started).
+      // by not having started), and PrerenderContents that are expected to
+      // be left in the manager until the test finishes.
       EXPECT_TRUE(prerender_contents == NULL ||
                   !prerender_contents->prerendering_has_started());
     }
   }
 
   void NavigateToURLImpl(const GURL& dest_url,
                          WindowOpenDisposition disposition) const {
     ASSERT_TRUE(GetPrerenderManager() != NULL);
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_TRUE(GetPrerenderContents() != NULL);
@@ skipping 46 matching lines @@
   // Opens the prerendered page using javascript functions in the
   // loader page. |javascript_function_name| should be a 0 argument function
   // which is invoked.
   void OpenDestURLWithJSImpl(const std::string& javascript_function_name)
       const {
     TestPrerenderContents* prerender_contents = GetPrerenderContents();
     ASSERT_TRUE(prerender_contents != NULL);
 
     RenderViewHost* render_view_host =
         chrome::GetActiveWebContents(current_browser())->GetRenderViewHost();
-    render_view_host->ExecuteJavascriptInWebFrame(
-        string16(),
-        ASCIIToUTF16(javascript_function_name));
 
-    // Run message loop until the prerender contents is destroyed.
-    ui_test_utils::RunMessageLoop();
+    if (prerender_contents->WillQuitMessageLoopOnDestruction()) {
+      render_view_host->ExecuteJavascriptInWebFrame(
+          string16(), ASCIIToUTF16(javascript_function_name));
+      // Run message loop until the prerender contents is destroyed.
+      ui_test_utils::RunMessageLoop();
+    } else {
+      // We don't expect to pick up a running prerender, so instead
+      // observe one navigation.
+      content::TestNavigationObserver observer(
+          content::NotificationService::AllSources(), NULL, 1);
+      render_view_host->ExecuteJavascriptInWebFrame(
+          string16(), ASCIIToUTF16(javascript_function_name));

[mmenke, 2012/07/13 14:49:10]

nit:  I was wrong about creating the observer first, was thinking of the
Windowed observer.  TestNavigationObserver isn't that smart.  I'd suggest just
moving this line back up outside the loop, so you only need one copy of the
line.

[gavinp, 2012/07/13 16:42:43]

Done.

+      base::RunLoop run_loop;
+      observer.WaitForObservation(
+          base::Bind(&ui_test_utils::RunThisRunLoop,
+                     base::Unretained(&run_loop)),
+          ui_test_utils::GetQuitTaskForRunLoop(&run_loop));
+    }
   }
 
   WaitForLoadPrerenderContentsFactory* prerender_contents_factory_;
 #if defined(ENABLE_SAFE_BROWSING)
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
 #endif
   GURL dest_url_;
   bool use_https_src_server_;
   bool call_javascript_;
   std::string loader_path_;
@@ skipping 462 matching lines @@
   std::deque<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
   PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
   ASSERT_TRUE(GetPrerenderContents());
   GetPrerenderContents()->WaitForPendingPrerenders(1u);
 
   // Next url should be in pending list but not an active entry.
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
-  EXPECT_TRUE(UrlIsPendingInPrerenderManager(kHtmlFileB));
+  EXPECT_TRUE(UrlIsPending(kHtmlFileB));
 
   NavigateToDestURL();
 
   // Make sure the PrerenderContents for the next url is now in the manager
   // and not pending.
   EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
-  EXPECT_FALSE(UrlIsPendingInPrerenderManager(kHtmlFileB));
+  EXPECT_FALSE(UrlIsPending(kHtmlFileB));
 }
 
 // Checks that we don't prerender in an infinite loop and multiple links are
 // handled correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderInfiniteLoopMultiple) {
   const char* const kHtmlFileA =
       "files/prerender/prerender_infinite_a_multiple.html";
   const char* const kHtmlFileB =
       "files/prerender/prerender_infinite_b_multiple.html";
   const char* const kHtmlFileC =
       "files/prerender/prerender_infinite_c_multiple.html";
 
   // We need to set the final status to expect here before starting any
   // prerenders. We set them on a queue so whichever we see first is expected to
   // be evicted, and the second should stick around until we exit.
   std::deque<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_EVICTED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
   PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
   ASSERT_TRUE(GetPrerenderContents());
   GetPrerenderContents()->WaitForPendingPrerenders(2u);
 
   // Next url should be in pending list but not an active entry.
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileC));
-  EXPECT_TRUE(UrlIsPendingInPrerenderManager(kHtmlFileB));
-  EXPECT_TRUE(UrlIsPendingInPrerenderManager(kHtmlFileC));
+  EXPECT_TRUE(UrlIsPending(kHtmlFileB));
+  EXPECT_TRUE(UrlIsPending(kHtmlFileC));
 
   NavigateToDestURL();
 
   // Make sure the PrerenderContents for the next urls are now in the manager
   // and not pending. One and only one of the URLs (the last seen) should be the
   // active entry.
   bool url_b_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileB);
   bool url_c_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileC);
   EXPECT_TRUE((url_b_is_active_prerender || url_c_is_active_prerender) &&
               !(url_b_is_active_prerender && url_c_is_active_prerender));
-  EXPECT_FALSE(UrlIsPendingInPrerenderManager(kHtmlFileB));
-  EXPECT_FALSE(UrlIsPendingInPrerenderManager(kHtmlFileC));
+  EXPECT_FALSE(UrlIsPending(kHtmlFileB));
+  EXPECT_FALSE(UrlIsPending(kHtmlFileC));
 }
 
 // See crbug.com/131836.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderTaskManager) {
   // Show the task manager. This populates the model.
   current_browser()->window()->ShowTaskManager();
   // Wait for the model of task manager to start.
   TaskManagerBrowserTestUtil::WaitForResourceChange(2);
 
   // Start with two resources.
@@ skipping 132 matching lines @@
           std::string());
   ui_test_utils::RunMessageLoop();
 }
 
 // Checks that we correctly use a prerendered page when navigating to a
 // fragment.
 // DISABLED: http://crbug.com/84154
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderPageNavigateFragment) {
   PrerenderTestURL("files/prerender/prerender_fragment.html",
-                   FINAL_STATUS_FRAGMENT_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   NavigateToURL("files/prerender/prerender_fragment.html#fragment");
 }
 
 // Checks that we correctly use a prerendered page when we prerender a fragment
 // but navigate to the main page.
 // http://crbug.com/83901
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderFragmentNavigatePage) {
   PrerenderTestURL("files/prerender/prerender_fragment.html#fragment",
-                   FINAL_STATUS_FRAGMENT_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   NavigateToURL("files/prerender/prerender_fragment.html");
 }
 
 // Checks that we correctly use a prerendered page when we prerender a fragment
 // but navigate to a different fragment on the same page.
 // DISABLED: http://crbug.com/84154
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderFragmentNavigateFragment) {
   PrerenderTestURL("files/prerender/prerender_fragment.html#other_fragment",
-                   FINAL_STATUS_FRAGMENT_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   NavigateToURL("files/prerender/prerender_fragment.html#fragment");
 }
 
 // Checks that we correctly use a prerendered page when the page uses a client
 // redirect to refresh from a fragment on the same page.
 // http://crbug.com/83901
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderClientRedirectFromFragment) {
   PrerenderTestURL(
       CreateClientRedirect("files/prerender/prerender_fragment.html#fragment"),
-      FINAL_STATUS_FRAGMENT_MISMATCH,
+      FINAL_STATUS_APP_TERMINATING,
       2);
   NavigateToURL("files/prerender/prerender_fragment.html");
 }
 
 // Checks that we correctly use a prerendered page when the page uses a client
 // redirect to refresh to a fragment on the same page.
 // DISABLED: http://crbug.com/84154
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderClientRedirectToFragment) {
   PrerenderTestURL(
       CreateClientRedirect("files/prerender/prerender_fragment.html"),
-      FINAL_STATUS_FRAGMENT_MISMATCH,
+      FINAL_STATUS_APP_TERMINATING,
       2);
   NavigateToURL("files/prerender/prerender_fragment.html#fragment");
 }
 
 // Checks that we correctly use a prerendered page when the page uses JS to set
 // the window.location.hash to a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageChangeFragmentLocationHash) {
   PrerenderTestURL("files/prerender/prerender_fragment_location_hash.html",
                    FINAL_STATUS_USED,
@@ skipping 141 matching lines @@
   PrerenderTestURL("files/prerender/prerender_print.html",
                    FINAL_STATUS_WINDOW_PRINT,
                    1);
 }
 
 // Checks that if a page is opened in a new window by javascript and both the
 // pages are in the same domain, the prerendered page is not used.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSameDomainWindowOpenerWindowOpen) {
   PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_WINDOW_OPENER,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaWindowOpen();
 }
 
 // Checks that if a page is opened due to click on a href with target="_blank"
 // and both pages are in the same domain the prerendered page is not used.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSameDomainWindowOpenerClickTarget) {
   PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_WINDOW_OPENER,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickTarget();
 }
 
 // Checks that a top-level page which would normally request an SSL client
 // certificate will never be seen since it's an https top-level resource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertTopLevel) {
   net::TestServer::HTTPSOptions https_options;
   https_options.request_client_certificate = true;
   net::TestServer https_server(https_options,
@@ skipping 262 matching lines @@
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
                    FINAL_STATUS_USED,
                    1);
   OpenDestURLViaClick();
   NavigateToNextPageAfterPrerender();
   GoBackToPrerender();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewWindow) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickNewWindow();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewForegroundTab) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickNewForegroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewBackgroundTab) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickNewBackgroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        NavigateToPrerenderedPageWhenDevToolsAttached) {
   DisableJavascriptCalls();
   WebContents* web_contents = chrome::GetActiveWebContents(current_browser());
   DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
       web_contents->GetRenderViewHost());
@@ skipping 84 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLReferrerPolicy) {
   set_use_https_src(true);
   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender