Convert WindowOpenDisposition to an enum class.

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 <stddef.h>
 #include <deque>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ skipping 1164 matching lines @@
         1, expected_final_status);
     std::vector<TestPrerender*> prerenders;
     PrerenderTestURLImpl(url,
                          expected_final_status_queue,
                          expected_number_of_loads).release(&prerenders);
     CHECK_EQ(1u, prerenders.size());
     return std::unique_ptr<TestPrerender>(prerenders[0]);
   }
 
   void NavigateToDestURL() const {
-    NavigateToDestURLWithDisposition(CURRENT_TAB, true);
+    NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, true);
   }
 
   // Opens the url in a new tab, with no opener.
   void NavigateToDestURLWithDisposition(
       WindowOpenDisposition disposition,
       bool expect_swap_to_succeed) const {
     NavigateToURLWithParams(
         content::OpenURLParams(dest_url_, Referrer(), disposition,
                                ui::PAGE_TRANSITION_TYPED, false),
         expect_swap_to_succeed);
   }
 
   void NavigateToURL(const std::string& dest_html_file) const {
-    NavigateToURLWithDisposition(dest_html_file, CURRENT_TAB, true);
+    NavigateToURLWithDisposition(dest_html_file,
+                                 WindowOpenDisposition::CURRENT_TAB, true);
   }
 
   void NavigateToURLWithDisposition(const std::string& dest_html_file,
                                     WindowOpenDisposition disposition,
                                     bool expect_swap_to_succeed) const {
     GURL dest_url = embedded_test_server()->GetURL(dest_html_file);
     NavigateToURLWithDisposition(dest_url, disposition, expect_swap_to_succeed);
   }
 
   void NavigateToURLWithDisposition(const GURL& dest_url,
@@ skipping 62 matching lines @@
   void NavigateToNextPageAfterPrerender() const {
     ui_test_utils::NavigateToURL(
         current_browser(),
         embedded_test_server()->GetURL("/prerender/prerender_page.html"));
   }
 
   // Called after the prerendered page has been navigated to and then away from.
   // Navigates back through the history to the prerendered page.
   void GoBackToPrerender() {
     TestNavigationObserver back_nav_observer(GetActiveWebContents());
-    chrome::GoBack(current_browser(), CURRENT_TAB);
+    chrome::GoBack(current_browser(), WindowOpenDisposition::CURRENT_TAB);
     back_nav_observer.Wait();
     bool original_prerender_page = false;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
         GetActiveWebContents(),
         "window.domAutomationController.send(IsOriginalPrerenderPage())",
         &original_prerender_page));
     EXPECT_TRUE(original_prerender_page);
   }
 
   // Goes back to the page that was active before the prerender was swapped
   // in. This must be called when the prerendered page is the current page
   // in the active tab.
   void GoBackToPageBeforePrerender() {
     WebContents* tab = GetActiveWebContents();
     ASSERT_TRUE(tab);
     EXPECT_FALSE(tab->IsLoading());
     TestNavigationObserver back_nav_observer(tab);
-    chrome::GoBack(current_browser(), CURRENT_TAB);
+    chrome::GoBack(current_browser(), WindowOpenDisposition::CURRENT_TAB);
     back_nav_observer.Wait();
     bool js_result;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
@@ skipping 309 matching lines @@
     ASSERT_TRUE(GetPrerenderManager());
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_TRUE(GetPrerenderContents());
 
     WebContents* web_contents = GetPrerenderContents()->prerender_contents();
 
     // Navigate and wait for either the load to finish normally or for a swap to
     // occur.
     // TODO(davidben): The only handles CURRENT_TAB navigations, which is the
     // only case tested or prerendered right now.
-    CHECK_EQ(CURRENT_TAB, params.disposition);
+    CHECK_EQ(WindowOpenDisposition::CURRENT_TAB, params.disposition);
     NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
                                            GetActiveWebContents());
     WebContents* target_web_contents = current_browser()->OpenURL(params);
     swap_observer.Wait();
 
     if (web_contents && expect_swap_to_succeed) {
       EXPECT_EQ(web_contents, target_web_contents);
       if (call_javascript_)
         EXPECT_TRUE(DidDisplayPass(web_contents));
     }
@@ skipping 107 matching lines @@
 
   const GURL prerender_page_url =
       embedded_test_server()->GetURL("/prerender/prerender_page.html");
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
   EXPECT_TRUE(GetPrerenderContentsFor(prerender_page_url));
 
   // Now navigate to our target page.
   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
                                          GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(), prerender_page_url, CURRENT_TAB,
+      current_browser(), prerender_page_url, WindowOpenDisposition::CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that pending prerenders which are canceled before they are launched
 // never get started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovesPending) {
   PrerenderTestURL("/prerender/prerender_page_removes_pending.html",
@@ skipping 145 matching lines @@
       base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
                  prerender_start_loop.QuitClosure()));
   DisableJavascriptCalls();
   PrerenderTestURL(kNoCommitUrl,
                    FINAL_STATUS_NAVIGATION_UNCOMMITTED,
                    0);
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigate to the URL, but assume the contents won't be swapped in.
-  NavigateToDestURLWithDisposition(CURRENT_TAB, false);
+  NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // Checks that client redirects don't add alias URLs until after they commit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap2) {
   // Navigate to a page that then navigates to a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(GetTestPath("prerender_page.html"));
 
   base::RunLoop prerender_start_loop;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
                  prerender_start_loop.QuitClosure()));
   DisableJavascriptCalls();
   PrerenderTestURL(CreateClientRedirect(kNoCommitUrl.spec()),
                    FINAL_STATUS_APP_TERMINATING, 1);
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigating to the second URL should not swap.
-  NavigateToURLWithDisposition(kNoCommitUrl, CURRENT_TAB, false);
+  NavigateToURLWithDisposition(kNoCommitUrl, WindowOpenDisposition::CURRENT_TAB,
+                               false);
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
   PrerenderTestURL("/prerender/prerender_alert_before_onload.html",
                    FINAL_STATUS_JAVASCRIPT_ALERT, 0);
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
@@ skipping 172 matching lines @@
                                       0);
 
   GURL navigate_url = embedded_test_server()->GetURL(
       "/prerender/prerender_location_replace.html?" +
       net::EscapeQueryParamValue(dest_url.spec(), false) + "#navigate");
   navigate_url = navigate_url.ReplaceComponents(replacements);
 
   NavigationOrSwapObserver swap_observer(
       current_browser()->tab_strip_model(),
       GetActiveWebContents(), 2);
-  current_browser()->OpenURL(OpenURLParams(
-      navigate_url, Referrer(), CURRENT_TAB,
-      ui::PAGE_TRANSITION_TYPED, false));
+  current_browser()->OpenURL(OpenURLParams(navigate_url, Referrer(),
+                                           WindowOpenDisposition::CURRENT_TAB,
+                                           ui::PAGE_TRANSITION_TYPED, false));
   swap_observer.Wait();
 
   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 
   histogram_tester().ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT",
                                       0);
   histogram_tester().ExpectTotalCount("Prerender.gws_PerceivedPLT", 1);
   histogram_tester().ExpectTotalCount("Prerender.gws_PerceivedPLTMatched", 1);
   histogram_tester().ExpectTotalCount(
       "Prerender.gws_PerceivedPLTMatchedComplete", 1);
@@ skipping 490 matching lines @@
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that we do not use a prerendered page when navigating from
 // the main page to a fragment.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageNavigateFragment) {
   PrerenderTestURL("/prerender/no_prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
   NavigateToURLWithDisposition("/prerender/no_prerender_page.html#fragment",
-                               CURRENT_TAB, false);
+                               WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // Checks that we do not use a prerendered page when we prerender a fragment
 // but navigate to the main page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderFragmentNavigatePage) {
   PrerenderTestURL("/prerender/no_prerender_page.html#fragment",
                    FINAL_STATUS_APP_TERMINATING, 1);
-  NavigateToURLWithDisposition("/prerender/no_prerender_page.html", CURRENT_TAB,
-                               false);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html",
+                               WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // Checks that we do not use a prerendered page when we prerender a fragment
 // but navigate to a different fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderFragmentNavigateFragment) {
   PrerenderTestURL("/prerender/no_prerender_page.html#other_fragment",
                    FINAL_STATUS_APP_TERMINATING, 1);
   NavigateToURLWithDisposition("/prerender/no_prerender_page.html#fragment",
-                               CURRENT_TAB, false);
+                               WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // Checks that we do not use a prerendered page when the page uses a client
 // redirect to refresh from a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectFromFragment) {
   PrerenderTestURL(
       CreateClientRedirect("/prerender/no_prerender_page.html#fragment"),
       FINAL_STATUS_APP_TERMINATING, 2);
-  NavigateToURLWithDisposition("/prerender/no_prerender_page.html", CURRENT_TAB,
-                               false);
+  NavigateToURLWithDisposition("/prerender/no_prerender_page.html",
+                               WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // Checks that we do not use a prerendered page when the page uses a client
 // redirect to refresh to a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectToFragment) {
   PrerenderTestURL(CreateClientRedirect("/prerender/no_prerender_page.html"),
                    FINAL_STATUS_APP_TERMINATING, 2);
   NavigateToURLWithDisposition("/prerender/no_prerender_page.html#fragment",
-                               CURRENT_TAB, false);
+                               WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // 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("/prerender/prerender_fragment_location_hash.html",
                    FINAL_STATUS_USED, 1);
   NavigateToURL("/prerender/prerender_fragment_location_hash.html");
 }
@@ skipping 123 matching lines @@
 
 // Checks that prerenders do not get swapped into target pages that have opened
 // popups; the BrowsingInstance is not empty.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderTargetHasPopup) {
   PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE, 1);
   OpenURLViaWindowOpen(GURL(url::kAboutBlankURL));
 
   // Switch back to the current tab and attempt to swap it in.
   current_browser()->tab_strip_model()->ActivateTabAt(0, true);
-  NavigateToDestURLWithDisposition(CURRENT_TAB, false);
+  NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 class TestClientCertStore : public net::ClientCertStore {
  public:
   explicit TestClientCertStore(const net::CertificateList& certs)
       : certs_(certs) {}
   ~TestClientCertStore() override {}
 
   // net::ClientCertStore:
   void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
@@ skipping 377 matching lines @@
                        NavigateToPrerenderedPageWhenDevToolsAttached) {
   DisableJavascriptCalls();
   WebContents* web_contents =
       current_browser()->tab_strip_model()->GetActiveWebContents();
   scoped_refptr<DevToolsAgentHost> agent(
       DevToolsAgentHost::GetOrCreateFor(web_contents));
   FakeDevToolsClient client;
   agent->AttachClient(&client);
   const char* url = "/prerender/prerender_page.html";
   PrerenderTestURL(url, FINAL_STATUS_DEVTOOLS_ATTACHED, 1);
-  NavigateToURLWithDisposition(url, CURRENT_TAB, false);
+  NavigateToURLWithDisposition(url, WindowOpenDisposition::CURRENT_TAB, false);
   agent->DetachClient(&client);
 }
 
 // Validate that the sessionStorage namespace remains the same when swapping
 // in a prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorage) {
   set_loader_path("/prerender/prerender_loader_with_session_storage.html");
   PrerenderTestURL(GetCrossDomainTestUrl("prerender/prerender_page.html"),
                    FINAL_STATUS_USED, 1);
   NavigateToDestURL();
@@ skipping 274 matching lines @@
   PrerenderTestURL("/prerender/prerender_web_audio_device.html",
                    FINAL_STATUS_CREATING_AUDIO_STREAM, 0);
 }
 
 // Checks that prerenders do not swap in to WebContents being captured.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCapturedWebContents) {
   PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_PAGE_BEING_CAPTURED, 1);
   WebContents* web_contents = GetActiveWebContents();
   web_contents->IncrementCapturerCount(gfx::Size());
-  NavigateToDestURLWithDisposition(CURRENT_TAB, false);
+  NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
   web_contents->DecrementCapturerCount();
 }
 
 // Checks that prerenders are aborted on cross-process navigation from
 // a server redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCrossProcessServerRedirect) {
   // Force everything to be a process swap.
   SwapProcessesContentBrowserClient test_browser_client;
   content::ContentBrowserClient* original_browser_client =
@@ skipping 62 matching lines @@
   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.none_PerceivedPLTMatchedComplete", 0);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PrerenderNotSwappedInPLT", 0);
 
   // Swap.
   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
                                          GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(), dest_url(), CURRENT_TAB,
+      current_browser(), dest_url(), WindowOpenDisposition::CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
 
   // The prerender never observes the final load.
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Now check DidDisplayPass.
   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 
   histogram_tester().ExpectTotalCount(
@@ skipping 16 matching lines @@
   std::unique_ptr<TestPrerender> prerender = PrerenderTestURL(
       "/prerender/prerender_deferred_image.html", FINAL_STATUS_USED, 0);
   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Swap.
   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
                                          GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(), dest_url(), CURRENT_TAB,
+      current_browser(), dest_url(), WindowOpenDisposition::CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
 
   // The prerender never observes the final load.
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Now check DidDisplayPass.
   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 }
 
@@ skipping 19 matching lines @@
   PrerenderTestURL("/prerender/prerender_deferred_sync_xhr.html",
                    FINAL_STATUS_BAD_DEFERRED_REDIRECT, 0);
   ui_test_utils::NavigateToURL(current_browser(), dest_url());
 }
 
 // Checks that prerenders are not swapped for navigations with extra headers.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExtraHeadersNoSwap) {
   PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
-  content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
+  content::OpenURLParams params(dest_url(), Referrer(),
+                                WindowOpenDisposition::CURRENT_TAB,
                                 ui::PAGE_TRANSITION_TYPED, false);
   params.extra_headers = "X-Custom-Header: 42\r\n";
   NavigateToURLWithParams(params, false);
 }
 
 // Checks that prerenders are not swapped for navigations with browser-initiated
 // POST data.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderBrowserInitiatedPostNoSwap) {
   PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   std::string post_data = "DATA";
-  content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
+  content::OpenURLParams params(dest_url(), Referrer(),
+                                WindowOpenDisposition::CURRENT_TAB,
                                 ui::PAGE_TRANSITION_TYPED, false);
   params.uses_post = true;
   params.post_data = content::ResourceRequestBody::CreateFromBytes(
       post_data.data(), post_data.size());
   NavigateToURLWithParams(params, false);
 }
 
 // Checks that the prerendering of a page is canceled correctly when the
 // prerendered page tries to make a second navigation entry.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNewNavigationEntry) {
   PrerenderTestURL("/prerender/prerender_new_entry.html",
                    FINAL_STATUS_NEW_NAVIGATION_ENTRY, 1);
 }
 
 // Attempt a swap-in in a new tab. The session storage doesn't match, so it
 // should not swap.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTab) {
   PrerenderTestURL("/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(), GURL(url::kAboutBlankURL), NEW_FOREGROUND_TAB,
+      current_browser(), GURL(url::kAboutBlankURL),
+      WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Now navigate in the new tab.
-  NavigateToDestURLWithDisposition(CURRENT_TAB, false);
+  NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // Checks that prerenders honor |should_replace_current_entry|.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReplaceCurrentEntry) {
   PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
-  content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
+  content::OpenURLParams params(dest_url(), Referrer(),
+                                WindowOpenDisposition::CURRENT_TAB,
                                 ui::PAGE_TRANSITION_TYPED, false);
   params.should_replace_current_entry = true;
   NavigateToURLWithParams(params, false);
 
   const NavigationController& controller =
       GetActiveWebContents()->GetController();
   // First entry is about:blank, second is prerender_page.html.
   EXPECT_FALSE(controller.GetPendingEntry());
   ASSERT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
@@ skipping 179 matching lines @@
       StartOmniboxPrerender(embedded_test_server()->GetURL("/empty.html?2"),
                             FINAL_STATUS_APP_TERMINATING);
 
   // The final status may be either FINAL_STATUS_APP_TERMINATING or
   // FINAL_STATUS_CANCELLED. Although closing the omnibox will not cancel an
   // abandoned prerender, the AutocompleteActionPredictor will cancel the
   // predictor on destruction.
   prerender->contents()->set_skip_final_checks(true);
 
   // Navigate to the URL entered.
-  omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
+  omnibox_view->model()->AcceptInput(WindowOpenDisposition::CURRENT_TAB, false);
 
   // Prerender should be running, but abandoned.
   EXPECT_TRUE(
       GetAutocompleteActionPredictor()->IsPrerenderAbandonedForTesting());
 }
 
 // Can't run tests with NaCl plugins if built with DISABLE_NACL.
 #if !defined(DISABLE_NACL)
 class PrerenderBrowserTestWithNaCl : public PrerenderBrowserTest {
  public:
@@ skipping 26 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents();
   bool display_test_result = false;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
                                                    "DidDisplayReallyPass()",
                                                    &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 #endif  // !defined(DISABLE_NACL)
 
 }  // namespace prerender