Move about://-related constants from //content to //url

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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 2886 matching lines @@
                    1);
   OpenDestURLViaClickTarget();
 }
 
 // Checks that prerenders do not get swapped into target pages that have opened
 // a popup, even if the target page itself does not have an opener.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderTargetHasPopup) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
                    1);
-  OpenURLViaWindowOpen(GURL(content::kAboutBlankURL));
+  OpenURLViaWindowOpen(GURL(url::kAboutBlankURL));
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 }
 
 class TestClientCertStore : public net::ClientCertStore {
  public:
   TestClientCertStore() {}
   virtual ~TestClientCertStore() {}
 
   // net::ClientCertStore:
   virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
@@ skipping 1084 matching lines @@
                  kTestURL, test_file, counter.AsWeakPtr()));
 
   PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), kInitURL, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Navigate to about:blank so the next navigation is cross-process.
-  ui_test_utils::NavigateToURL(current_browser(),
-                               GURL(content::kAboutBlankURL));
+  ui_test_utils::NavigateToURL(current_browser(), GURL(url::kAboutBlankURL));
 
   // Now navigate in the new tab. Set expect_swap_to_succeed to false because
   // the swap does not occur synchronously.
   //
   // TODO(davidben): When all swaps become asynchronous, remove the OpenURL
   // return value assertion and let this go through the usual successful-swap
   // codepath.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 
   // Verify DidDisplayPass manually since the previous call skipped it.
@@ skipping 32 matching lines @@
   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
                                 content::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_TRUE(controller.GetPendingEntry() == NULL);
   EXPECT_EQ(2, controller.GetEntryCount());
-  EXPECT_EQ(GURL(content::kAboutBlankURL),
-            controller.GetEntryAtIndex(0)->GetURL());
+  EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
   EXPECT_EQ(dest_url(), controller.GetEntryAtIndex(1)->GetURL());
 }
 
 // Checks prerender does not hit DCHECKs and behaves properly if two pending
 // swaps occur in a row.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDoublePendingSwap) {
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
 
   GURL url1 = test_server()->GetURL("files/prerender/prerender_page.html?1");
   scoped_ptr<TestPrerender> prerender1 =
       PrerenderTestURL(url1, FINAL_STATUS_APP_TERMINATING, 1);
 
   GURL url2 = test_server()->GetURL("files/prerender/prerender_page.html?2");
   scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
   AddPrerender(url2, 1);
   prerender2->WaitForStart();
   prerender2->WaitForLoads(1);
 
   // There's no reason the second prerender can't be used, but the swap races
   // with didStartProvisionalLoad and didFailProvisionalLoad from the previous
   // navigation. The current logic will conservatively fail to swap under such
   // races. However, if the renderer is slow enough, it's possible for the
   // prerender to still be used, so don't program in either expectation.
   ASSERT_TRUE(prerender2->contents());
   prerender2->contents()->set_skip_final_checks(true);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB,
+      current_browser(),
+      GURL(url::kAboutBlankURL),
+      NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Fire off two navigations, without running the event loop between them.
   NavigationOrSwapObserver swap_observer(
       current_browser()->tab_strip_model(),
       GetActiveWebContents(), 2);
   current_browser()->OpenURL(OpenURLParams(
       url1, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
   current_browser()->OpenURL(OpenURLParams(
       url2, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
   swap_observer.Wait();
 
   // The WebContents should be on url2. There may be 2 or 3 entries, depending
   // on whether the first one managed to complete.
   //
   // TODO(davidben): When http://crbug.com/335835 is fixed, the 3 entry case
   // shouldn't be possible because it's throttled by the pending swap that
   // cannot complete.
   const NavigationController& controller =
       GetActiveWebContents()->GetController();
   EXPECT_TRUE(controller.GetPendingEntry() == NULL);
   EXPECT_LE(2, controller.GetEntryCount());
   EXPECT_GE(3, controller.GetEntryCount());
-  EXPECT_EQ(GURL(content::kAboutBlankURL),
-            controller.GetEntryAtIndex(0)->GetURL());
+  EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
   EXPECT_EQ(url2, controller.GetEntryAtIndex(
       controller.GetEntryCount() - 1)->GetURL());
 }
 
 // Verify that pending swaps get aborted on new navigations.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPendingSwapNewNavigation) {
   PrerenderManager::HangSessionStorageMergesForTesting();
 
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB,
+      current_browser(),
+      GURL(url::kAboutBlankURL),
+      NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Navigate to the URL. Wait for DidStartLoading, just so it's definitely
   // progressed somewhere.
   content::WindowedNotificationObserver page_load_observer(
       content::NOTIFICATION_LOAD_START,
       content::Source<NavigationController>(
           &GetActiveWebContents()->GetController()));
   current_browser()->OpenURL(OpenURLParams(
       dest_url(), Referrer(), CURRENT_TAB,
       content::PAGE_TRANSITION_TYPED, false));
   page_load_observer.Wait();
 
   // Navigate somewhere else. This should succeed and abort the pending swap.
   TestNavigationObserver nav_observer(GetActiveWebContents());
-  current_browser()->OpenURL(OpenURLParams(
-      GURL(content::kAboutBlankURL), Referrer(), CURRENT_TAB,
-      content::PAGE_TRANSITION_TYPED, false));
+  current_browser()->OpenURL(OpenURLParams(GURL(url::kAboutBlankURL),
+                                           Referrer(),
+                                           CURRENT_TAB,
+                                           content::PAGE_TRANSITION_TYPED,
+                                           false));
   nav_observer.Wait();
 }
 
 // Checks that <a ping> requests are not dropped in prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPing) {
   // Count hits to a certain URL.
   const GURL kPingURL("http://prerender.test/ping");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   RequestCounter ping_counter;
@@ skipping 241 matching lines @@
 
   // Navigate to the URL entered.
   omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
 
   // Prerender should be running, but abandoned.
   EXPECT_TRUE(
       GetAutocompleteActionPredictor()->IsPrerenderAbandonedForTesting());
 }
 
 }  // namespace prerender