Move a bunch more code into the content namespace.

content/browser/web_contents/web_contents_impl_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 "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/interstitial_page_impl.h"
@@ skipping 12 matching lines @@
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "googleurl/src/url_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/glue/webkit_glue.h"
 
-using content::BrowserContext;
-using content::BrowserThread;
-using content::InterstitialPage;
-using content::MockRenderProcessHost;
-using content::NavigationEntry;
-using content::NavigationEntryImpl;
-using content::PasswordForm;
-using content::SiteInstance;
-using content::RenderViewHost;
-using content::RenderViewHostImplTestHarness;
-using content::TestBrowserThread;
-using content::TestRenderViewHost;
-using content::TestWebContents;
-using content::WebContents;
-using content::WebUI;
-using content::WebUIController;
-
+namespace content {
 namespace {
 
 class WebContentsImplTestWebUIControllerFactory
-    : public content::WebUIControllerFactory {
+    : public WebUIControllerFactory {
  public:
   virtual WebUIController* CreateWebUIControllerForURL(
-      content::WebUI* web_ui, const GURL& url) const OVERRIDE {
-   if (!content::GetContentClient()->HasWebUIScheme(url))
+      WebUI* web_ui, const GURL& url) const OVERRIDE {
+   if (!GetContentClient()->HasWebUIScheme(url))
      return NULL;
 
    return new WebUIController(web_ui);
   }
 
   virtual WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
       const GURL& url) const OVERRIDE {
     return WebUI::kNoWebUI;
   }
 
   virtual bool UseWebUIForURL(BrowserContext* browser_context,
                               const GURL& url) const OVERRIDE {
-    return content::GetContentClient()->HasWebUIScheme(url);
+    return GetContentClient()->HasWebUIScheme(url);
   }
 
   virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
                                       const GURL& url) const OVERRIDE {
-    return content::GetContentClient()->HasWebUIScheme(url);
+    return GetContentClient()->HasWebUIScheme(url);
   }
 
   virtual bool IsURLAcceptableForWebUI(
       BrowserContext* browser_context,
       const GURL& url,
       bool data_urls_allowed) const {
-    return content::GetContentClient()->HasWebUIScheme(url);
+    return GetContentClient()->HasWebUIScheme(url);
   }
 };
 
 class WebContentsImplTestContentClient : public TestContentClient {
  public:
   WebContentsImplTestContentClient() {
   }
 
   virtual bool HasWebUIScheme(const GURL& url) const OVERRIDE {
     return url.SchemeIs("webcontentsimpltest");
   }
 };
 
-class WebContentsImplTestBrowserClient
-    : public content::TestContentBrowserClient {
+class WebContentsImplTestBrowserClient : public TestContentBrowserClient {
  public:
   WebContentsImplTestBrowserClient() {
   }
 
-  virtual content::WebUIControllerFactory*
-      GetWebUIControllerFactory() OVERRIDE {
+  virtual WebUIControllerFactory* GetWebUIControllerFactory() OVERRIDE {
     return &factory_;
   }
 
  private:
   WebContentsImplTestWebUIControllerFactory factory_;
 };
 
 class TestInterstitialPage;
 
-class TestInterstitialPageDelegate : public content::InterstitialPageDelegate {
+class TestInterstitialPageDelegate : public InterstitialPageDelegate {
  public:
   TestInterstitialPageDelegate(TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {}
   virtual void CommandReceived(const std::string& command) OVERRIDE;
   virtual std::string GetHTMLContents() OVERRIDE { return std::string(); }
   virtual void OnDontProceed() OVERRIDE;
   virtual void OnProceed() OVERRIDE;
  private:
   TestInterstitialPage* interstitial_page_;
 };
@@ skipping 60 matching lines @@
     return command_received_count_;
   }
 
   void TestDomOperationResponse(const std::string& json_string) {
     if (enabled())
       CommandReceived();
   }
 
   void TestDidNavigate(int page_id, const GURL& url) {
     ViewHostMsg_FrameNavigate_Params params;
-    InitNavigateParams(&params, page_id, url, content::PAGE_TRANSITION_TYPED);
+    InitNavigateParams(&params, page_id, url, PAGE_TRANSITION_TYPED);
     DidNavigate(GetRenderViewHostForTesting(), params);
   }
 
   void TestRenderViewGone(base::TerminationStatus status, int error_code) {
     RenderViewGone(GetRenderViewHostForTesting(), status, error_code);
   }
 
   bool is_showing() const {
-    return static_cast<content::TestRenderWidgetHostView*>(
+    return static_cast<TestRenderWidgetHostView*>(
         GetRenderViewHostForTesting()->GetView())->is_showing();
   }
 
   void ClearStates() {
     state_ = NULL;
     deleted_ = NULL;
     delegate_ = NULL;
   }
 
   void CommandReceived() {
     command_received_count_++;
   }
 
   void set_delegate(Delegate* delegate) {
     delegate_ = delegate;
   }
 
  protected:
-  virtual content::RenderViewHost* CreateRenderViewHost() OVERRIDE {
+  virtual RenderViewHost* CreateRenderViewHost() OVERRIDE {
     return new TestRenderViewHost(
         SiteInstance::Create(web_contents()->GetBrowserContext()),
         this, this, MSG_ROUTING_NONE, false);
   }
 
-  virtual content::WebContentsView* CreateWebContentsView() OVERRIDE {
+  virtual WebContentsView* CreateWebContentsView() OVERRIDE {
     return NULL;
   }
 
  private:
   InterstitialState* state_;
   bool* deleted_;
   int command_received_count_;
   Delegate* delegate_;
 };
 
@@ skipping 40 matching lines @@
         file_user_blocking_thread_(
             BrowserThread::FILE_USER_BLOCKING, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_) {
   }
 
   virtual void SetUp() {
     // These tests treat webcontentsimpltest as a privileged WebUI scheme.
     // We must register it similarly to kChromeUIScheme.
     url_util::AddStandardScheme("webcontentsimpltest");
 
-    old_client_ = content::GetContentClient();
-    old_browser_client_ = content::GetContentClient()->browser();
-    content::SetContentClient(&client_);
-    content::GetContentClient()->set_browser_for_testing(&browser_client_);
+    old_client_ = GetContentClient();
+    old_browser_client_ = GetContentClient()->browser();
+    SetContentClient(&client_);
+    GetContentClient()->set_browser_for_testing(&browser_client_);
     RenderViewHostImplTestHarness::SetUp();
   }
 
   virtual void TearDown() {
-    content::GetContentClient()->set_browser_for_testing(old_browser_client_);
-    content::SetContentClient(old_client_);
+    GetContentClient()->set_browser_for_testing(old_browser_client_);
+    SetContentClient(old_client_);
     RenderViewHostImplTestHarness::TearDown();
   }
 
  private:
   WebContentsImplTestContentClient client_;
   WebContentsImplTestBrowserClient browser_client_;
-  content::ContentClient* old_client_;
-  content::ContentBrowserClient* old_browser_client_;
+  ContentClient* old_client_;
+  ContentBrowserClient* old_browser_client_;
   TestBrowserThread ui_thread_;
   TestBrowserThread file_user_blocking_thread_;
   TestBrowserThread io_thread_;
 };
 
 }  // namespace
 
 // Test to make sure that title updates get stripped of whitespace.
 TEST_F(WebContentsImplTest, UpdateTitle) {
   NavigationControllerImpl& cont =
       static_cast<NavigationControllerImpl&>(controller());
   ViewHostMsg_FrameNavigate_Params params;
   InitNavigateParams(&params, 0, GURL(chrome::kAboutBlankURL),
-                     content::PAGE_TRANSITION_TYPED);
+                     PAGE_TRANSITION_TYPED);
 
-  content::LoadCommittedDetails details;
+  LoadCommittedDetails details;
   cont.RendererDidNavigate(params, &details);
 
   contents()->UpdateTitle(rvh(), 0, ASCIIToUTF16("    Lots O' Whitespace\n"),
                           base::i18n::LEFT_TO_RIGHT);
   EXPECT_EQ(ASCIIToUTF16("Lots O' Whitespace"), contents()->GetTitle());
 }
 
 // Test view source mode for a webui page.
 TEST_F(WebContentsImplTest, NTPViewSource) {
   NavigationControllerImpl& cont =
       static_cast<NavigationControllerImpl&>(controller());
   const char kUrl[] = "view-source:webcontentsimpltest://blah";
   const GURL kGURL(kUrl);
 
   process()->sink().ClearMessages();
 
   cont.LoadURL(
-      kGURL, content::Referrer(), content::PAGE_TRANSITION_TYPED,
-      std::string());
+      kGURL, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   rvh()->GetDelegate()->RenderViewCreated(rvh());
   // Did we get the expected message?
   EXPECT_TRUE(process()->sink().GetFirstMessageMatching(
       ViewMsg_EnableViewSourceMode::ID));
 
   ViewHostMsg_FrameNavigate_Params params;
-  InitNavigateParams(&params, 0, kGURL, content::PAGE_TRANSITION_TYPED);
-  content::LoadCommittedDetails details;
+  InitNavigateParams(&params, 0, kGURL, PAGE_TRANSITION_TYPED);
+  LoadCommittedDetails details;
   cont.RendererDidNavigate(params, &details);
   // Also check title and url.
   EXPECT_EQ(ASCIIToUTF16(kUrl), contents()->GetTitle());
 }
 
 // Test to ensure UpdateMaxPageID is working properly.
 TEST_F(WebContentsImplTest, UpdateMaxPageID) {
   SiteInstance* instance1 = contents()->GetSiteInstance();
   scoped_refptr<SiteInstance> instance2(SiteInstance::Create(NULL));
 
@@ skipping 17 matching lines @@
 
 // Test simple same-SiteInstance navigation.
 TEST_F(WebContentsImplTest, SimpleNavigation) {
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 
   // Navigate to URL
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(instance1, orig_rvh->GetSiteInstance());
   // Controller's pending entry will have a NULL site instance until we assign
   // it in DidNavigate.
   EXPECT_TRUE(
       NavigationEntryImpl::FromNavigationEntry(controller().GetActiveEntry())->
           site_instance() == NULL);
 
   // DidNavigate from the page
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(instance1, orig_rvh->GetSiteInstance());
   // Controller's entry should now have the SiteInstance, or else we won't be
   // able to find it later.
   EXPECT_EQ(
       instance1,
       NavigationEntryImpl::FromNavigationEntry(controller().GetActiveEntry())->
           site_instance());
 }
 
-// Test that we reject NavigateToEntry if the url is over content::kMaxURLChars.
+// Test that we reject NavigateToEntry if the url is over kMaxURLChars.
 TEST_F(WebContentsImplTest, NavigateToExcessivelyLongURL) {
   // Construct a URL that's kMaxURLChars + 1 long of all 'a's.
   const GURL url(std::string("http://example.org/").append(
-      content::kMaxURLChars + 1, 'a'));
+      kMaxURLChars + 1, 'a'));
 
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_GENERATED,
-      std::string());
+      url, Referrer(), PAGE_TRANSITION_GENERATED, std::string());
   EXPECT_TRUE(controller().GetActiveEntry() == NULL);
 }
 
 // Test that navigating across a site boundary creates a new RenderViewHost
 // with a new SiteInstance.  Going back should do the same.
 TEST_F(WebContentsImplTest, CrossSiteBoundaries) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   int orig_rvh_delete_count = 0;
   orig_rvh->set_delete_counter(&orig_rvh_delete_count);
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* pending_rvh =
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   int pending_rvh_delete_count = 0;
   pending_rvh->set_delete_counter(&pending_rvh_delete_count);
 
   // Navigations should be suspended in pending_rvh until ShouldCloseACK.
   EXPECT_TRUE(pending_rvh->are_navigations_suspended());
   orig_rvh->SendShouldCloseACK(true);
   EXPECT_FALSE(pending_rvh->are_navigations_suspended());
 
   // DidNavigate from the pending page
   contents()->TestDidNavigate(
-      pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+      pending_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, contents()->GetRenderViewHost());
   EXPECT_NE(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
   // We keep the original RVH around, swapped out.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->IsSwappedOut(orig_rvh));
   EXPECT_EQ(orig_rvh_delete_count, 0);
 
   // Going back should switch SiteInstances again.  The first SiteInstance is
   // stored in the NavigationEntry, so it should be the same as at the start.
   // We should use the same RVH as before, swapping it back in.
   controller().GoBack();
   TestRenderViewHost* goback_rvh =
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(orig_rvh, goback_rvh);
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Navigations should be suspended in goback_rvh until ShouldCloseACK.
   EXPECT_TRUE(goback_rvh->are_navigations_suspended());
   pending_rvh->SendShouldCloseACK(true);
   EXPECT_FALSE(goback_rvh->are_navigations_suspended());
 
   // DidNavigate from the back action
   contents()->TestDidNavigate(
-      goback_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+      goback_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(goback_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(instance1, contents()->GetSiteInstance());
   // The pending RVH should now be swapped out, not deleted.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->
       IsSwappedOut(pending_rvh));
   EXPECT_EQ(pending_rvh_delete_count, 0);
 
   // Close contents and ensure RVHs are deleted.
   DeleteContents();
   EXPECT_EQ(orig_rvh_delete_count, 1);
   EXPECT_EQ(pending_rvh_delete_count, 1);
 }
 
 // Test that navigating across a site boundary after a crash creates a new
 // RVH without requiring a cross-site transition (i.e., PENDING state).
 TEST_F(WebContentsImplTest, CrossSiteBoundariesAfterCrash) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   int orig_rvh_delete_count = 0;
   orig_rvh->set_delete_counter(&orig_rvh_delete_count);
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Crash the renderer.
   orig_rvh->set_render_view_created(false);
 
   // Navigate to new site.  We should not go into PENDING.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   RenderViewHost* new_rvh = rvh();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
   EXPECT_NE(orig_rvh, new_rvh);
   EXPECT_EQ(orig_rvh_delete_count, 1);
 
   // DidNavigate from the new page
-  contents()->TestDidNavigate(new_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(new_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(new_rvh, rvh());
   EXPECT_NE(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 
   // Close contents and ensure RVHs are deleted.
   DeleteContents();
   EXPECT_EQ(orig_rvh_delete_count, 1);
 }
 
 // Test that opening a new contents in the same SiteInstance and then navigating
 // both contentses to a new site will place both contentses in a single
 // SiteInstance.
 TEST_F(WebContentsImplTest, NavigateTwoTabsCrossSite) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
 
   // Open a new contents with the same SiteInstance, navigated to the same site.
   scoped_ptr<TestWebContents> contents2(
       TestWebContents::Create(browser_context_.get(), instance1));
   contents2->transition_cross_site = true;
-  contents2->GetController().LoadURL(url, content::Referrer(),
-                                    content::PAGE_TRANSITION_TYPED,
+  contents2->GetController().LoadURL(url, Referrer(),
+                                    PAGE_TRANSITION_TYPED,
                                     std::string());
   // Need this page id to be 2 since the site instance is the same (which is the
   // scope of page IDs) and we want to consider this a new page.
   contents2->TestDidNavigate(
-      contents2->GetRenderViewHost(), 2, url, content::PAGE_TRANSITION_TYPED);
+      contents2->GetRenderViewHost(), 2, url, PAGE_TRANSITION_TYPED);
 
   // Navigate first contents to a new site.
   const GURL url2a("http://www.yahoo.com");
   controller().LoadURL(
-      url2a, content::Referrer(), content::PAGE_TRANSITION_TYPED,
-      std::string());
+      url2a, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   orig_rvh->SendShouldCloseACK(true);
   TestRenderViewHost* pending_rvh_a =
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   contents()->TestDidNavigate(
-      pending_rvh_a, 1, url2a, content::PAGE_TRANSITION_TYPED);
+      pending_rvh_a, 1, url2a, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2a = contents()->GetSiteInstance();
   EXPECT_NE(instance1, instance2a);
 
   // Navigate second contents to the same site as the first tab.
   const GURL url2b("http://mail.yahoo.com");
-  contents2->GetController().LoadURL(url2b, content::Referrer(),
-                                    content::PAGE_TRANSITION_TYPED,
+  contents2->GetController().LoadURL(url2b, Referrer(),
+                                    PAGE_TRANSITION_TYPED,
                                     std::string());
   TestRenderViewHost* rvh2 =
       static_cast<TestRenderViewHost*>(contents2->GetRenderViewHost());
   rvh2->SendShouldCloseACK(true);
   TestRenderViewHost* pending_rvh_b =
       static_cast<TestRenderViewHost*>(contents2->GetPendingRenderViewHost());
   EXPECT_TRUE(pending_rvh_b != NULL);
   EXPECT_TRUE(contents2->cross_navigation_pending());
 
   // NOTE(creis): We used to be in danger of showing a crash page here if the
   // second contents hadn't navigated somewhere first (bug 1145430).  That case
   // is now covered by the CrossSiteBoundariesAfterCrash test.
   contents2->TestDidNavigate(
-      pending_rvh_b, 2, url2b, content::PAGE_TRANSITION_TYPED);
+      pending_rvh_b, 2, url2b, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2b = contents2->GetSiteInstance();
   EXPECT_NE(instance1, instance2b);
 
   // Both contentses should now be in the same SiteInstance.
   EXPECT_EQ(instance2a, instance2b);
 }
 
 // Tests that WebContentsImpl uses the current URL, not the SiteInstance's site,
 // to determine whether a navigation is cross-site.
 TEST_F(WebContentsImplTest, CrossSiteComparesAgainstCurrentPage) {
   contents()->transition_cross_site = true;
   RenderViewHost* orig_rvh = rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   contents()->TestDidNavigate(
-      orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
 
   // Open a related contents to a second site.
   scoped_ptr<TestWebContents> contents2(
       TestWebContents::Create(browser_context_.get(), instance1));
   contents2->transition_cross_site = true;
   const GURL url2("http://www.yahoo.com");
-  contents2->GetController().LoadURL(url2, content::Referrer(),
-                                    content::PAGE_TRANSITION_TYPED,
+  contents2->GetController().LoadURL(url2, Referrer(),
+                                    PAGE_TRANSITION_TYPED,
                                     std::string());
   // The first RVH in contents2 isn't live yet, so we shortcut the cross site
   // pending.
   TestRenderViewHost* rvh2 = static_cast<TestRenderViewHost*>(
       contents2->GetRenderViewHost());
   EXPECT_FALSE(contents2->cross_navigation_pending());
-  contents2->TestDidNavigate(rvh2, 2, url2, content::PAGE_TRANSITION_TYPED);
+  contents2->TestDidNavigate(rvh2, 2, url2, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents2->GetSiteInstance();
   EXPECT_NE(instance1, instance2);
   EXPECT_FALSE(contents2->cross_navigation_pending());
 
   // Simulate a link click in first contents to second site.  Doesn't switch
   // SiteInstances, because we don't intercept WebKit navigations.
   contents()->TestDidNavigate(
-      orig_rvh, 2, url2, content::PAGE_TRANSITION_TYPED);
+      orig_rvh, 2, url2, PAGE_TRANSITION_TYPED);
   SiteInstance* instance3 = contents()->GetSiteInstance();
   EXPECT_EQ(instance1, instance3);
   EXPECT_FALSE(contents()->cross_navigation_pending());
 
   // Navigate to the new site.  Doesn't switch SiteInstancees, because we
   // compare against the current URL, not the SiteInstance's site.
   const GURL url3("http://mail.yahoo.com");
   controller().LoadURL(
-      url3, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url3, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   contents()->TestDidNavigate(
-      orig_rvh, 3, url3, content::PAGE_TRANSITION_TYPED);
+      orig_rvh, 3, url3, PAGE_TRANSITION_TYPED);
   SiteInstance* instance4 = contents()->GetSiteInstance();
   EXPECT_EQ(instance1, instance4);
 }
 
 // Test that the onbeforeunload and onunload handlers run when navigating
 // across site boundaries.
 TEST_F(WebContentsImplTest, CrossSiteUnloadHandlers) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, but simulate an onbeforeunload denial.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
   orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, false, base::TimeTicks(), base::TimeTicks()));
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate again, but simulate an onbeforeunload approval.
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
   orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* pending_rvh = static_cast<TestRenderViewHost*>(
       contents()->GetPendingRenderViewHost());
 
   // We won't hear DidNavigate until the onunload handler has finished running.
   // (No way to simulate that here, but it involves a call from RDH to
   // WebContentsImpl::OnCrossSiteResponse.)
 
   // DidNavigate from the pending page
   contents()->TestDidNavigate(
-      pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+      pending_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, rvh());
   EXPECT_NE(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 // Test that during a slow cross-site navigation, the original renderer can
 // navigate to a different URL and have it displayed, canceling the slow
 // navigation.
 TEST_F(WebContentsImplTest, CrossSiteNavigationPreempted) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
   orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Suppose the original renderer navigates before the new one is ready.
   orig_rvh->SendNavigate(2, GURL("http://www.google.com/foo"));
 
   // Verify that the pending navigation is cancelled.
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, rvh());
   EXPECT_EQ(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 TEST_F(WebContentsImplTest, CrossSiteNavigationBackPreempted) {
   contents()->transition_cross_site = true;
 
   // Start with a web ui page, which gets a new RVH with WebUI bindings.
   const GURL url1("webcontentsimpltest://blah");
   controller().LoadURL(
-      url1, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url1, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* ntp_rvh = test_rvh();
-  contents()->TestDidNavigate(ntp_rvh, 1, url1, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(ntp_rvh, 1, url1, PAGE_TRANSITION_TYPED);
   NavigationEntry* entry1 = controller().GetLastCommittedEntry();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(ntp_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(url1, entry1->GetURL());
   EXPECT_EQ(instance1,
             NavigationEntryImpl::FromNavigationEntry(entry1)->site_instance());
-  EXPECT_TRUE(ntp_rvh->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI);
+  EXPECT_TRUE(ntp_rvh->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 
   // Navigate to new site.
   const GURL url2("http://www.google.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* google_rvh =
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
 
   // Simulate beforeunload approval.
   EXPECT_TRUE(ntp_rvh->is_waiting_for_beforeunload_ack());
   ntp_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
 
   // DidNavigate from the pending page.
   contents()->TestDidNavigate(
-      google_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+      google_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   NavigationEntry* entry2 = controller().GetLastCommittedEntry();
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(google_rvh, contents()->GetRenderViewHost());
   EXPECT_NE(instance1, instance2);
   EXPECT_FALSE(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(url2, entry2->GetURL());
   EXPECT_EQ(instance2,
             NavigationEntryImpl::FromNavigationEntry(entry2)->site_instance());
-  EXPECT_FALSE(google_rvh->GetEnabledBindings() &
-      content::BINDINGS_POLICY_WEB_UI);
+  EXPECT_FALSE(google_rvh->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 
   // Navigate to third page on same site.
   const GURL url3("http://news.google.com");
   controller().LoadURL(
-      url3, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url3, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   contents()->TestDidNavigate(
-      google_rvh, 2, url3, content::PAGE_TRANSITION_TYPED);
+      google_rvh, 2, url3, PAGE_TRANSITION_TYPED);
   NavigationEntry* entry3 = controller().GetLastCommittedEntry();
   SiteInstance* instance3 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(google_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(instance2, instance3);
   EXPECT_FALSE(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(url3, entry3->GetURL());
   EXPECT_EQ(instance3,
             NavigationEntryImpl::FromNavigationEntry(entry3)->site_instance());
 
   // Go back within the site.
   controller().GoBack();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(entry2, controller().GetPendingEntry());
 
   // Before that commits, go back again.
   controller().GoBack();
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(entry1, controller().GetPendingEntry());
 
   // Simulate beforeunload approval.
   EXPECT_TRUE(google_rvh->is_waiting_for_beforeunload_ack());
   google_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
 
   // DidNavigate from the first back. This aborts the second back's pending RVH.
-  contents()->TestDidNavigate(
-      google_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(google_rvh, 1, url2, PAGE_TRANSITION_TYPED);
 
   // We should commit this page and forget about the second back.
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_FALSE(controller().GetPendingEntry());
   EXPECT_EQ(google_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(url2, controller().GetLastCommittedEntry()->GetURL());
 
   // We should not have corrupted the NTP entry.
   EXPECT_EQ(instance3,
             NavigationEntryImpl::FromNavigationEntry(entry3)->site_instance());
   EXPECT_EQ(instance2,
             NavigationEntryImpl::FromNavigationEntry(entry2)->site_instance());
   EXPECT_EQ(instance1,
             NavigationEntryImpl::FromNavigationEntry(entry1)->site_instance());
   EXPECT_EQ(url1, entry1->GetURL());
 }
 
 // Test that during a slow cross-site navigation, a sub-frame navigation in the
 // original renderer will not cancel the slow navigation (bug 42029).
 TEST_F(WebContentsImplTest, CrossSiteNavigationNotPreemptedByFrame) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Start navigating to new site.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
 
   // Simulate a sub-frame navigation arriving and ensure the RVH is still
   // waiting for a before unload response.
   orig_rvh->SendNavigateWithTransition(1, GURL("http://google.com/frame"),
-                                       content::PAGE_TRANSITION_AUTO_SUBFRAME);
+                                       PAGE_TRANSITION_AUTO_SUBFRAME);
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // Now simulate the onbeforeunload approval and verify the navigation is
   // not canceled.
   orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   EXPECT_TRUE(contents()->cross_navigation_pending());
 }
 
 // Test that a cross-site navigation is not preempted if the previous
 // renderer sends a FrameNavigate message just before being told to stop.
 // We should only preempt the cross-site navigation if the previous renderer
 // has started a new navigation.  See http://crbug.com/79176.
 TEST_F(WebContentsImplTest, CrossSiteNotPreemptedDuringBeforeUnload) {
   contents()->transition_cross_site = true;
 
   // Navigate to NTP URL.
   const GURL url("webcontentsimpltest://blah");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* orig_rvh = test_rvh();
   EXPECT_FALSE(contents()->cross_navigation_pending());
 
   // Navigate to new site, with the beforeunload request in flight.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* pending_rvh =
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // Suppose the first navigation tries to commit now, with a
   // ViewMsg_Stop in flight.  This should not cancel the pending navigation,
   // but it should act as if the beforeunload ack arrived.
   orig_rvh->SendNavigate(1, GURL("webcontentsimpltest://blah"));
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // The pending navigation should be able to commit successfully.
-  contents()->TestDidNavigate(
-      pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(pending_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, contents()->GetRenderViewHost());
 }
 
 // Test that the original renderer cannot preempt a cross-site navigation once
 // the unload request has been made.  At this point, the cross-site navigation
 // is almost ready to be displayed, and the original renderer is only given a
 // short chance to run an unload handler.  Prevents regression of bug 23942.
 TEST_F(WebContentsImplTest, CrossSiteCantPreemptAfterUnload) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* pending_rvh = static_cast<TestRenderViewHost*>(
       contents()->GetPendingRenderViewHost());
 
   // Simulate the pending renderer's response, which leads to an unload request
   // being sent to orig_rvh.
   contents()->GetRenderManagerForTesting()->OnCrossSiteResponse(0, 0);
 
   // Suppose the original renderer navigates now, while the unload request is in
   // flight.  We should ignore it, wait for the unload ack, and let the pending
   // request continue.  Otherwise, the contents may close spontaneously or stop
   // responding to navigation requests.  (See bug 23942.)
   ViewHostMsg_FrameNavigate_Params params1a;
   InitNavigateParams(&params1a, 2, GURL("http://www.google.com/foo"),
-                     content::PAGE_TRANSITION_TYPED);
+                     PAGE_TRANSITION_TYPED);
   orig_rvh->SendNavigate(2, GURL("http://www.google.com/foo"));
 
   // Verify that the pending navigation is still in progress.
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() != NULL);
 
   // DidNavigate from the pending page should commit it.
   contents()->TestDidNavigate(
-      pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
+      pending_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, rvh());
   EXPECT_NE(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 // Test that a cross-site navigation that doesn't commit after the unload
 // handler doesn't leave the contents in a stuck state.  http://crbug.com/88562
 TEST_F(WebContentsImplTest, CrossSiteNavigationCanceled) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
-  controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
   orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Simulate swap out message when the response arrives.
   orig_rvh->set_is_swapped_out(true);
 
   // Suppose the navigation doesn't get a chance to commit, and the user
   // navigates in the current RVH's SiteInstance.
-  controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
 
   // Verify that the pending navigation is cancelled and the renderer is no
   // longer swapped out.
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, rvh());
   EXPECT_FALSE(orig_rvh->is_swapped_out());
   EXPECT_EQ(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 // Test that NavigationEntries have the correct content state after going
 // forward and back.  Prevents regression for bug 1116137.
 TEST_F(WebContentsImplTest, NavigationEntryContentState) {
   TestRenderViewHost* orig_rvh = test_rvh();
 
   // Navigate to URL.  There should be no committed entry yet.
   const GURL url("http://www.google.com");
-  controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   NavigationEntry* entry = controller().GetLastCommittedEntry();
   EXPECT_TRUE(entry == NULL);
 
   // Committed entry should have content state after DidNavigate.
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   entry = controller().GetLastCommittedEntry();
   EXPECT_FALSE(entry->GetContentState().empty());
 
   // Navigate to same site.
   const GURL url2("http://images.google.com");
-  controller().LoadURL(
-      url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   entry = controller().GetLastCommittedEntry();
   EXPECT_FALSE(entry->GetContentState().empty());
 
   // Committed entry should have content state after DidNavigate.
-  contents()->TestDidNavigate(
-      orig_rvh, 2, url2, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 2, url2, PAGE_TRANSITION_TYPED);
   entry = controller().GetLastCommittedEntry();
   EXPECT_FALSE(entry->GetContentState().empty());
 
   // Now go back.  Committed entry should still have content state.
   controller().GoBack();
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
   entry = controller().GetLastCommittedEntry();
   EXPECT_FALSE(entry->GetContentState().empty());
 }
 
 // Test that NavigationEntries have the correct content state and SiteInstance
 // state after opening a new window to about:blank.  Prevents regression for
 // bugs b/1116137 and http://crbug.com/111975.
 TEST_F(WebContentsImplTest, NavigationEntryContentStateNewWindow) {
   TestRenderViewHost* orig_rvh = test_rvh();
 
   // When opening a new window, it is navigated to about:blank internally.
   // Currently, this results in two DidNavigate events.
   const GURL url(chrome::kAboutBlankURL);
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
-  contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 1, url, PAGE_TRANSITION_TYPED);
 
   // Should have a content state here.
   NavigationEntry* entry = controller().GetLastCommittedEntry();
   EXPECT_FALSE(entry->GetContentState().empty());
 
   // The SiteInstance should be available for other navigations to use.
   NavigationEntryImpl* entry_impl =
       NavigationEntryImpl::FromNavigationEntry(entry);
   EXPECT_FALSE(entry_impl->site_instance()->HasSite());
   int32 site_instance_id = entry_impl->site_instance()->GetId();
 
   // Navigating to a normal page should not cause a process swap.
   const GURL new_url("http://www.google.com");
-  controller().LoadURL(new_url, content::Referrer(),
-                       content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(new_url, Referrer(),
+                       PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
-  contents()->TestDidNavigate(orig_rvh, 1, new_url,
-                              content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(orig_rvh, 1, new_url, PAGE_TRANSITION_TYPED);
   NavigationEntryImpl* entry_impl2 = NavigationEntryImpl::FromNavigationEntry(
       controller().GetLastCommittedEntry());
   EXPECT_EQ(site_instance_id, entry_impl2->site_instance()->GetId());
   EXPECT_TRUE(entry_impl2->site_instance()->HasSite());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Interstitial Tests
 ////////////////////////////////////////////////////////////////////////////////
 
 // Test navigating to a page (with the navigation initiated from the browser,
 // as when a URL is typed in the location bar) that shows an interstitial and
 // creates a new navigation entry, then hiding it without proceeding.
 TEST_F(WebContentsImplTest,
        ShowInterstitialFromBrowserWithNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   test_rvh()->SendNavigate(1, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
-  controller().LoadURL(GURL("http://www.evil.com"), content::Referrer(),
-                        content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(GURL("http://www.evil.com"), Referrer(),
+                        PAGE_TRANSITION_TYPED, std::string());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
@@ skipping 115 matching lines @@
 // as when a URL is typed in the location bar) that shows an interstitial and
 // creates a new navigation entry, then proceeding.
 TEST_F(WebContentsImplTest,
        ShowInterstitialFromBrowserNewNavigationProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   test_rvh()->SendNavigate(1, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
-  controller().LoadURL(GURL("http://www.evil.com"), content::Referrer(),
-                        content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(GURL("http://www.evil.com"), Referrer(),
+                        PAGE_TRANSITION_TYPED, std::string());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
@@ skipping 422 matching lines @@
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
 
   // Let's simulate a navigation initiated from the browser before the
   // interstitial finishes loading.
   const GURL url("http://www.google.com");
-  controller().LoadURL(
-      url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   ASSERT_FALSE(deleted);
   EXPECT_FALSE(interstitial->is_showing());
 
   // Now let's make the interstitial navigation commit.
   interstitial->TestDidNavigate(1, interstitial_url);
 
   // After it loaded the interstitial should be gone.
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 }
@@ skipping 70 matching lines @@
 
 // Tests that showing an interstitial as a result of a browser initiated
 // navigation while an interstitial is showing does not remove the pending
 // entry (see http://crbug.com/9791).
 TEST_F(WebContentsImplTest, NewInterstitialDoesNotCancelPendingEntry) {
   const char kUrl[] = "http://www.badguys.com/";
   const GURL kGURL(kUrl);
 
   // Start a navigation to a page
   contents()->GetController().LoadURL(
-      kGURL, content::Referrer(), content::PAGE_TRANSITION_TYPED,
-      std::string());
+      kGURL, Referrer(), PAGE_TRANSITION_TYPED, std::string());
 
   // Simulate that navigation triggering an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, kGURL, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   interstitial->TestDidNavigate(1, kGURL);
 
   // Initiate a new navigation from the browser that also triggers an
   // interstitial.
   contents()->GetController().LoadURL(
-      kGURL, content::Referrer(), content::PAGE_TRANSITION_TYPED,
-      std::string());
+      kGURL, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestInterstitialPage::InterstitialState state2 =
       TestInterstitialPage::UNDECIDED;
   bool deleted2 = false;
   TestInterstitialPage* interstitial2 =
       new TestInterstitialPage(contents(), true, kGURL, &state, &deleted);
   TestInterstitialPageStateGuard state_guard2(interstitial2);
   interstitial2->Show();
   interstitial2->TestDidNavigate(1, kGURL);
 
   // Make sure we still have an entry.
   NavigationEntry* entry = contents()->GetController().GetPendingEntry();
   ASSERT_TRUE(entry);
   EXPECT_EQ(kUrl, entry->GetURL().spec());
 
   // And that the first interstitial is gone, but not the second.
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
   EXPECT_FALSE(deleted2);
   EXPECT_EQ(TestInterstitialPage::UNDECIDED, state2);
 }
 
 // Tests that Javascript messages are not shown while an interstitial is
 // showing.
 TEST_F(WebContentsImplTest, NoJSMessageOnInterstitials) {
   const char kUrl[] = "http://www.badguys.com/";
   const GURL kGURL(kUrl);
 
   // Start a navigation to a page
   contents()->GetController().LoadURL(
-      kGURL, content::Referrer(), content::PAGE_TRANSITION_TYPED,
-      std::string());
+      kGURL, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   // DidNavigate from the page
-  contents()->TestDidNavigate(rvh(), 1, kGURL, content::PAGE_TRANSITION_TYPED);
+  contents()->TestDidNavigate(rvh(), 1, kGURL, PAGE_TRANSITION_TYPED);
 
   // Simulate showing an interstitial while the page is showing.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, kGURL, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   interstitial->TestDidNavigate(1, kGURL);
 
   // While the interstitial is showing, let's simulate the hidden page
   // attempting to show a JS message.
   IPC::Message* dummy_message = new IPC::Message;
   bool did_suppress_message = false;
   contents()->RunJavaScriptMessage(contents()->GetRenderViewHost(),
       ASCIIToUTF16("This is an informative message"), ASCIIToUTF16("OK"),
-      kGURL, content::JAVASCRIPT_MESSAGE_TYPE_ALERT, dummy_message,
+      kGURL, JAVASCRIPT_MESSAGE_TYPE_ALERT, dummy_message,
       &did_suppress_message);
   EXPECT_TRUE(did_suppress_message);
 }
 
 // Makes sure that if the source passed to CopyStateFromAndPrune has an
 // interstitial it isn't copied over to the destination.
 TEST_F(WebContentsImplTest, CopyStateFromAndPruneSourceInterstitial) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   test_rvh()->SendNavigate(1, url1);
   EXPECT_EQ(1, controller().GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
-  controller().LoadURL(GURL("http://www.evil.com"), content::Referrer(),
-                        content::PAGE_TRANSITION_TYPED, std::string());
+  controller().LoadURL(GURL("http://www.evil.com"), Referrer(),
+                        PAGE_TRANSITION_TYPED, std::string());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, url2, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
@@ skipping 67 matching lines @@
   // It should have a transient entry.
   EXPECT_TRUE(other_controller.GetTransientEntry());
 
   // And the interstitial should be showing.
   EXPECT_TRUE(other_contents->ShowingInterstitialPage());
 
   // And the interstitial should do a reload on don't proceed.
   EXPECT_TRUE(static_cast<InterstitialPageImpl*>(
       other_contents->GetInterstitialPage())->reload_on_dont_proceed());
 }
+
+}  // namespace content