Move a bunch more code into the content namespace.

content/browser/web_contents/navigation_controller_impl.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 "content/browser/web_contents/navigation_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"  // Temporary
@@ skipping 21 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "webkit/glue/glue_serialize.h"
 
-using content::BrowserContext;
-using content::DOMStorageContext;
-using content::GetContentClient;
-using content::GlobalRequestID;
-using content::NavigationController;
-using content::NavigationEntry;
-using content::NavigationEntryImpl;
-using content::RenderViewHostImpl;
-using content::SessionStorageNamespace;
-using content::SessionStorageNamespaceMap;
-using content::SiteInstance;
-using content::UserMetricsAction;
-using content::WebContents;
-
+namespace content {
 namespace {
 
 const int kInvalidateAll = 0xFFFFFFFF;
 
 // Invoked when entries have been pruned, or removed. For example, if the
 // current entries are [google, digg, yahoo], with the current entry google,
 // and the user types in cnet, then digg and yahoo are pruned.
 void NotifyPrunedEntries(NavigationControllerImpl* nav_controller,
                          bool from_front,
                          int count) {
-  content::PrunedDetails details;
+  PrunedDetails details;
   details.from_front = from_front;
   details.count = count;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_NAV_LIST_PRUNED,
-      content::Source<NavigationController>(nav_controller),
-      content::Details<content::PrunedDetails>(&details));
+  NotificationService::current()->Notify(
+      NOTIFICATION_NAV_LIST_PRUNED,
+      Source<NavigationController>(nav_controller),
+      Details<PrunedDetails>(&details));
 }
 
 // Ensure the given NavigationEntry has a valid state, so that WebKit does not
 // get confused if we navigate back to it.
 //
 // An empty state is treated as a new navigation by WebKit, which would mean
 // losing the navigation entries and generating a new navigation entry after
 // this one. We don't want that. To avoid this we create a valid state which
 // WebKit will not treat as a new navigation.
 void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
@@ skipping 18 matching lines @@
 }
 
 // Configure all the NavigationEntries in entries for restore. This resets
 // the transition type to reload and makes sure the content state isn't empty.
 void ConfigureEntriesForRestore(
     std::vector<linked_ptr<NavigationEntryImpl> >* entries,
     NavigationController::RestoreType type) {
   for (size_t i = 0; i < entries->size(); ++i) {
     // Use a transition type of reload so that we don't incorrectly increase
     // the typed count.
-    (*entries)[i]->SetTransitionType(content::PAGE_TRANSITION_RELOAD);
+    (*entries)[i]->SetTransitionType(PAGE_TRANSITION_RELOAD);
     (*entries)[i]->set_restore_type(ControllerRestoreTypeToEntryType(type));
     // NOTE(darin): This code is only needed for backwards compat.
     SetContentStateIfEmpty((*entries)[i].get());
   }
 }
 
 // See NavigationController::IsURLInPageNavigation for how this works and why.
 bool AreURLsInPageNavigation(const GURL& existing_url,
                              const GURL& new_url,
                              bool renderer_says_in_page) {
@@ skipping 11 matching lines @@
   }
 
   url_canon::Replacements<char> replacements;
   replacements.ClearRef();
   return existing_url.ReplaceComponents(replacements) ==
       new_url.ReplaceComponents(replacements);
 }
 
 // Determines whether or not we should be carrying over a user agent override
 // between two NavigationEntries.
-bool ShouldKeepOverride(const content::NavigationEntry* last_entry) {
+bool ShouldKeepOverride(const NavigationEntry* last_entry) {
   return last_entry && last_entry->GetIsOverridingUserAgent();
 }
 
 }  // namespace
 
 // NavigationControllerImpl ----------------------------------------------------
 
 const size_t kMaxEntryCountForTestingNotSet = -1;
 
 // static
 size_t NavigationControllerImpl::max_entry_count_for_testing_ =
     kMaxEntryCountForTestingNotSet;
 
  // Should Reload check for post data? The default is true, but is set to false
 // when testing.
 static bool g_check_for_repost = true;
 
-namespace content {
 // static
 NavigationEntry* NavigationController::CreateNavigationEntry(
       const GURL& url,
       const Referrer& referrer,
       PageTransition transition,
       bool is_renderer_initiated,
       const std::string& extra_headers,
       BrowserContext* browser_context) {
   // Allow the browser URL handler to rewrite the URL. This will, for example,
   // remove "view-source:" from the beginning of the URL to get the URL that
@@ skipping 18 matching lines @@
   entry->set_update_virtual_url_with_url(reverse_on_redirect);
   entry->set_extra_headers(extra_headers);
   return entry;
 }
 
 // static
 void NavigationController::DisablePromptOnRepost() {
   g_check_for_repost = false;
 }
 
-}  // namespace content
-
 base::Time NavigationControllerImpl::TimeSmoother::GetSmoothedTime(
     base::Time t) {
   // If |t| is between the water marks, we're in a run of duplicates
   // or just getting out of it, so increase the high-water mark to get
   // a time that probably hasn't been used before and return it.
   if (low_water_mark_ <= t && t <= high_water_mark_) {
     high_water_mark_ += base::TimeDelta::FromMicroseconds(1);
     return high_water_mark_;
   }
 
@@ skipping 67 matching lines @@
 }
 void NavigationControllerImpl::ReloadOriginalRequestURL(bool check_for_repost) {
   ReloadInternal(check_for_repost, RELOAD_ORIGINAL_REQUEST_URL);
 }
 
 void NavigationControllerImpl::ReloadInternal(bool check_for_repost,
                                               ReloadType reload_type) {
   if (transient_entry_index_ != -1) {
     // If an interstitial is showing, treat a reload as a navigation to the
     // transient entry's URL.
-    content::NavigationEntryImpl* active_entry =
+    NavigationEntryImpl* active_entry =
         NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
     if (!active_entry)
       return;
     LoadURL(active_entry->GetURL(),
-            content::Referrer(),
-            content::PAGE_TRANSITION_RELOAD,
+            Referrer(),
+            PAGE_TRANSITION_RELOAD,
             active_entry->extra_headers());
     return;
   }
 
   DiscardNonCommittedEntriesInternal();
   int current_index = GetCurrentEntryIndex();
   // If we are no where, then we can't reload.  TODO(darin): We should add a
   // CanReload method.
   if (current_index == -1) {
     return;
   }
 
   if (g_check_for_repost && check_for_repost &&
       GetEntryAtIndex(current_index)->GetHasPostData()) {
     // The user is asking to reload a page with POST data. Prompt to make sure
     // they really want to do this. If they do, the dialog will call us back
     // with check_for_repost = false.
-    content::NotificationService::current()->Notify(
-        content::NOTIFICATION_REPOST_WARNING_SHOWN,
-        content::Source<NavigationController>(this),
-        content::NotificationService::NoDetails());
+    NotificationService::current()->Notify(
+        NOTIFICATION_REPOST_WARNING_SHOWN,
+        Source<NavigationController>(this),
+        NotificationService::NoDetails());
 
     pending_reload_ = reload_type;
     web_contents_->Activate();
     web_contents_->GetDelegate()->ShowRepostFormWarningDialog(web_contents_);
   } else {
     DiscardNonCommittedEntriesInternal();
 
     NavigationEntryImpl* entry = entries_[current_index].get();
     SiteInstanceImpl* site_instance = entry->site_instance();
     DCHECK(site_instance);
@@ skipping 22 matching lines @@
       pending_entry_ = nav_entry;
     } else {
       pending_entry_index_ = current_index;
 
       // The title of the page being reloaded might have been removed in the
       // meanwhile, so we need to revert to the default title upon reload and
       // invalidate the previously cached title (SetTitle will do both).
       // See Chromium issue 96041.
       entries_[pending_entry_index_]->SetTitle(string16());
 
-      entries_[pending_entry_index_]->SetTransitionType(
-          content::PAGE_TRANSITION_RELOAD);
+      entries_[pending_entry_index_]->SetTransitionType(PAGE_TRANSITION_RELOAD);
     }
 
     NavigateToPendingEntry(reload_type);
   }
 }
 
 void NavigationControllerImpl::CancelPendingReload() {
   DCHECK(pending_reload_ != NO_RELOAD);
   pending_reload_ = NO_RELOAD;
 }
@@ skipping 29 matching lines @@
             << entry->GetURL();
     delete entry;
     return;
   }
 
   // When navigating to a new page, we don't know for sure if we will actually
   // end up leaving the current page.  The new page load could for example
   // result in a download or a 'no content' response (e.g., a mailto: URL).
   DiscardNonCommittedEntriesInternal();
   pending_entry_ = entry;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_NAV_ENTRY_PENDING,
-      content::Source<NavigationController>(this),
-      content::Details<NavigationEntry>(entry));
+  NotificationService::current()->Notify(
+      NOTIFICATION_NAV_ENTRY_PENDING,
+      Source<NavigationController>(this),
+      Details<NavigationEntry>(entry));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 NavigationEntry* NavigationControllerImpl::GetActiveEntry() const {
   if (transient_entry_index_ != -1)
     return entries_[transient_entry_index_].get();
   if (pending_entry_)
     return pending_entry_;
   return GetLastCommittedEntry();
 }
@@ skipping 85 matching lines @@
     return;
   }
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index - 1;
   entries_[pending_entry_index_]->SetTransitionType(
-      content::PageTransitionFromInt(
+      PageTransitionFromInt(
           entries_[pending_entry_index_]->GetTransitionType() |
-          content::PAGE_TRANSITION_FORWARD_BACK));
+          PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::GoForward() {
   if (!CanGoForward()) {
     NOTREACHED();
     return;
   }
 
   bool transient = (transient_entry_index_ != -1);
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index;
   // If there was a transient entry, we removed it making the current index
   // the next page.
   if (!transient)
     pending_entry_index_++;
 
   entries_[pending_entry_index_]->SetTransitionType(
-      content::PageTransitionFromInt(
+      PageTransitionFromInt(
           entries_[pending_entry_index_]->GetTransitionType() |
-          content::PAGE_TRANSITION_FORWARD_BACK));
+          PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::GoToIndex(int index) {
   if (index < 0 || index >= static_cast<int>(entries_.size())) {
     NOTREACHED();
     return;
   }
 
   if (transient_entry_index_ != -1) {
     if (index == transient_entry_index_) {
       // Nothing to do when navigating to the transient.
       return;
     }
     if (index > transient_entry_index_) {
       // Removing the transient is goint to shift all entries by 1.
       index--;
     }
   }
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = index;
   entries_[pending_entry_index_]->SetTransitionType(
-      content::PageTransitionFromInt(
+      PageTransitionFromInt(
           entries_[pending_entry_index_]->GetTransitionType() |
-          content::PAGE_TRANSITION_FORWARD_BACK));
+          PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::GoToOffset(int offset) {
   if (!CanGoToOffset(offset))
     return;
 
   GoToIndex(GetIndexForOffset(offset));
 }
 
@@ skipping 20 matching lines @@
     index = last_committed_entry_index_ + 1;
   DiscardTransientEntry();
   entries_.insert(
       entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
   transient_entry_index_ = index;
   web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 }
 
 void NavigationControllerImpl::LoadURL(
     const GURL& url,
-    const content::Referrer& referrer,
-    content::PageTransition transition,
+    const Referrer& referrer,
+    PageTransition transition,
     const std::string& extra_headers) {
   LoadURLParams params(url);
   params.referrer = referrer;
   params.transition_type = transition;
   params.extra_headers = extra_headers;
   LoadURLWithParams(params);
 }
 
 void NavigationControllerImpl::LoadURLWithParams(const LoadURLParams& params) {
-  if (content::HandleDebugURL(params.url, params.transition_type))
+  if (HandleDebugURL(params.url, params.transition_type))
     return;
 
   // Checks based on params.load_type.
   switch (params.load_type) {
     case LOAD_TYPE_DEFAULT:
       break;
     case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST:
       if (!params.url.SchemeIs(chrome::kHttpScheme) &&
           !params.url.SchemeIs(chrome::kHttpsScheme)) {
         NOTREACHED() << "Http post load must use http(s) scheme.";
@@ skipping 62 matching lines @@
 
   LoadEntry(entry);
 }
 
 void NavigationControllerImpl::DocumentLoadedInFrame() {
   is_initial_navigation_ = false;
 }
 
 bool NavigationControllerImpl::RendererDidNavigate(
     const ViewHostMsg_FrameNavigate_Params& params,
-    content::LoadCommittedDetails* details) {
+    LoadCommittedDetails* details) {
 
   // Save the previous state before we clobber it.
   if (GetLastCommittedEntry()) {
     details->previous_url = GetLastCommittedEntry()->GetURL();
     details->previous_entry_index = GetLastCommittedEntryIndex();
   } else {
     details->previous_url = GURL();
     details->previous_entry_index = -1;
   }
 
   // If we have a pending entry at this point, it should have a SiteInstance.
   // Restored entries start out with a null SiteInstance, but we should have
   // assigned one in NavigateToPendingEntry.
   DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance());
 
   // If we are doing a cross-site reload, we need to replace the existing
   // navigation entry, not add another entry to the history. This has the side
   // effect of removing forward browsing history, if such existed.
   details->did_replace_entry =
       pending_entry_ && pending_entry_->is_cross_site_reload();
 
   // is_in_page must be computed before the entry gets committed.
   details->is_in_page = IsURLInPageNavigation(
       params.url, params.was_within_same_page);
 
   // Do navigation-type specific actions. These will make and commit an entry.
   details->type = ClassifyNavigation(params);
 
   switch (details->type) {
-    case content::NAVIGATION_TYPE_NEW_PAGE:
+    case NAVIGATION_TYPE_NEW_PAGE:
       RendererDidNavigateToNewPage(params, details->did_replace_entry);
       break;
-    case content::NAVIGATION_TYPE_EXISTING_PAGE:
+    case NAVIGATION_TYPE_EXISTING_PAGE:
       RendererDidNavigateToExistingPage(params);
       break;
-    case content::NAVIGATION_TYPE_SAME_PAGE:
+    case NAVIGATION_TYPE_SAME_PAGE:
       RendererDidNavigateToSamePage(params);
       break;
-    case content::NAVIGATION_TYPE_IN_PAGE:
+    case NAVIGATION_TYPE_IN_PAGE:
       RendererDidNavigateInPage(params, &details->did_replace_entry);
       break;
-    case content::NAVIGATION_TYPE_NEW_SUBFRAME:
+    case NAVIGATION_TYPE_NEW_SUBFRAME:
       RendererDidNavigateNewSubframe(params);
       break;
-    case content::NAVIGATION_TYPE_AUTO_SUBFRAME:
+    case NAVIGATION_TYPE_AUTO_SUBFRAME:
       if (!RendererDidNavigateAutoSubframe(params))
         return false;
       break;
-    case content::NAVIGATION_TYPE_NAV_IGNORE:
+    case NAVIGATION_TYPE_NAV_IGNORE:
       // If a pending navigation was in progress, this canceled it.  We should
       // discard it and make sure it is removed from the URL bar.  After that,
       // there is nothing we can do with this navigation, so we just return to
       // the caller that nothing has happened.
       if (pending_entry_) {
         DiscardNonCommittedEntries();
-        web_contents_->NotifyNavigationStateChanged(
-            content::INVALIDATE_TYPE_URL);
+        web_contents_->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
       }
       return false;
     default:
       NOTREACHED();
   }
 
   // At this point, we know that the navigation has just completed, so
   // record the time.
   //
   // TODO(akalin): Use "sane time" as described in
@@ skipping 16 matching lines @@
   // Once committed, we do not need to track if the entry was initiated by
   // the renderer.
   active_entry->set_is_renderer_initiated(false);
 
   // The active entry's SiteInstance should match our SiteInstance.
   DCHECK(active_entry->site_instance() == web_contents_->GetSiteInstance());
 
   // Now prep the rest of the details for the notification and broadcast.
   details->entry = active_entry;
   details->is_main_frame =
-      content::PageTransitionIsMainFrame(params.transition);
+      PageTransitionIsMainFrame(params.transition);
   details->serialized_security_info = params.security_info;
   details->http_status_code = params.http_status_code;
   NotifyNavigationEntryCommitted(details);
 
   return true;
 }
 
-content::NavigationType NavigationControllerImpl::ClassifyNavigation(
+NavigationType NavigationControllerImpl::ClassifyNavigation(
     const ViewHostMsg_FrameNavigate_Params& params) const {
   if (params.page_id == -1) {
     // The renderer generates the page IDs, and so if it gives us the invalid
     // page ID (-1) we know it didn't actually navigate. This happens in a few
     // cases:
     //
     // - If a page makes a popup navigated to about blank, and then writes
     //   stuff like a subframe navigated to a real page. We'll get the commit
     //   for the subframe, but there won't be any commit for the outer page.
     //
     // - We were also getting these for failed loads (for example, bug 21849).
     //   The guess is that we get a "load commit" for the alternate error page,
     //   but that doesn't affect the page ID, so we get the "old" one, which
     //   could be invalid. This can also happen for a cross-site transition
     //   that causes us to swap processes. Then the error page load will be in
     //   a new process with no page IDs ever assigned (and hence a -1 value),
     //   yet the navigation controller still might have previous pages in its
     //   list.
     //
     // In these cases, there's nothing we can do with them, so ignore.
-    return content::NAVIGATION_TYPE_NAV_IGNORE;
+    return NAVIGATION_TYPE_NAV_IGNORE;
   }
 
   if (params.page_id > web_contents_->GetMaxPageID()) {
     // Greater page IDs than we've ever seen before are new pages. We may or may
     // not have a pending entry for the page, and this may or may not be the
     // main frame.
-    if (content::PageTransitionIsMainFrame(params.transition))
-      return content::NAVIGATION_TYPE_NEW_PAGE;
+    if (PageTransitionIsMainFrame(params.transition))
+      return NAVIGATION_TYPE_NEW_PAGE;
 
     // When this is a new subframe navigation, we should have a committed page
     // for which it's a suframe in. This may not be the case when an iframe is
     // navigated on a popup navigated to about:blank (the iframe would be
     // written into the popup by script on the main page). For these cases,
     // there isn't any navigation stuff we can do, so just ignore it.
     if (!GetLastCommittedEntry())
-      return content::NAVIGATION_TYPE_NAV_IGNORE;
+      return NAVIGATION_TYPE_NAV_IGNORE;
 
     // Valid subframe navigation.
-    return content::NAVIGATION_TYPE_NEW_SUBFRAME;
+    return NAVIGATION_TYPE_NEW_SUBFRAME;
   }
 
   // Now we know that the notification is for an existing page. Find that entry.
   int existing_entry_index = GetEntryIndexWithPageID(
       web_contents_->GetSiteInstance(),
       params.page_id);
   if (existing_entry_index == -1) {
     // The page was not found. It could have been pruned because of the limit on
     // back/forward entries (not likely since we'll usually tell it to navigate
     // to such entries). It could also mean that the renderer is smoking crack.
     NOTREACHED();
 
     // Because the unknown entry has committed, we risk showing the wrong URL in
     // release builds. Instead, we'll kill the renderer process to be safe.
     LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
-    content::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
+    RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
 
     // Temporary code so we can get more information.  Format:
     //  http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2
     std::string temp = params.url.spec();
     temp.append("#page");
     temp.append(base::IntToString(params.page_id));
     temp.append("#max");
     temp.append(base::IntToString(web_contents_->GetMaxPageID()));
     temp.append("#frame");
     temp.append(base::IntToString(params.frame_id));
@@ skipping 10 matching lines @@
       else
         temp.append("N");
       if (entries_[i]->site_instance() != web_contents_->GetSiteInstance())
         temp.append("x");
       temp.append(",");
     }
     GURL url(temp);
     static_cast<RenderViewHostImpl*>(
         web_contents_->GetRenderViewHost())->Send(
             new ViewMsg_TempCrashWithData(url));
-    return content::NAVIGATION_TYPE_NAV_IGNORE;
+    return NAVIGATION_TYPE_NAV_IGNORE;
   }
   NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
 
-  if (!content::PageTransitionIsMainFrame(params.transition)) {
+  if (!PageTransitionIsMainFrame(params.transition)) {
     // All manual subframes would get new IDs and were handled above, so we
     // know this is auto. Since the current page was found in the navigation
     // entry list, we're guaranteed to have a last committed entry.
     DCHECK(GetLastCommittedEntry());
-    return content::NAVIGATION_TYPE_AUTO_SUBFRAME;
+    return NAVIGATION_TYPE_AUTO_SUBFRAME;
   }
 
   // Anything below here we know is a main frame navigation.
   if (pending_entry_ &&
       existing_entry != pending_entry_ &&
       pending_entry_->GetPageID() == -1 &&
       existing_entry == GetLastCommittedEntry()) {
     // In this case, we have a pending entry for a URL but WebCore didn't do a
     // new navigation. This happens when you press enter in the URL bar to
     // reload. We will create a pending entry, but WebKit will convert it to
     // a reload since it's the same page and not create a new entry for it
     // (the user doesn't want to have a new back/forward entry when they do
     // this). If this matches the last committed entry, we want to just ignore
     // the pending entry and go back to where we were (the "existing entry").
-    return content::NAVIGATION_TYPE_SAME_PAGE;
+    return NAVIGATION_TYPE_SAME_PAGE;
   }
 
   // Any toplevel navigations with the same base (minus the reference fragment)
   // are in-page navigations. We weeded out subframe navigations above. Most of
   // the time this doesn't matter since WebKit doesn't tell us about subframe
   // navigations that don't actually navigate, but it can happen when there is
   // an encoding override (it always sends a navigation request).
   if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url,
                               params.was_within_same_page)) {
-    return content::NAVIGATION_TYPE_IN_PAGE;
+    return NAVIGATION_TYPE_IN_PAGE;
   }
 
   // Since we weeded out "new" navigations above, we know this is an existing
   // (back/forward) navigation.
-  return content::NAVIGATION_TYPE_EXISTING_PAGE;
+  return NAVIGATION_TYPE_EXISTING_PAGE;
 }
 
 bool NavigationControllerImpl::IsRedirect(
   const ViewHostMsg_FrameNavigate_Params& params) {
   // For main frame transition, we judge by params.transition.
   // Otherwise, by params.redirects.
-  if (content::PageTransitionIsMainFrame(params.transition)) {
-    return content::PageTransitionIsRedirect(params.transition);
+  if (PageTransitionIsMainFrame(params.transition)) {
+    return PageTransitionIsRedirect(params.transition);
   }
   return params.redirects.size() > 1;
 }
 
 void NavigationControllerImpl::RendererDidNavigateToNewPage(
    const ViewHostMsg_FrameNavigate_Params& params, bool replace_entry) {
   NavigationEntryImpl* new_entry;
   bool update_virtual_url;
   if (pending_entry_) {
     // TODO(brettw) this assumes that the pending entry is appropriate for the
     // new page that was just loaded. I don't think this is necessarily the
     // case! We should have some more tracking to know for sure.
     new_entry = new NavigationEntryImpl(*pending_entry_);
 
     // Don't use the page type from the pending entry. Some interstitial page
     // may have set the type to interstitial. Once we commit, however, the page
     // type must always be normal.
-    new_entry->set_page_type(content::PAGE_TYPE_NORMAL);
+    new_entry->set_page_type(PAGE_TYPE_NORMAL);
     update_virtual_url = new_entry->update_virtual_url_with_url();
   } else {
     new_entry = new NavigationEntryImpl;
 
     // Find out whether the new entry needs to update its virtual URL on URL
     // change and set up the entry accordingly. This is needed to correctly
     // update the virtual URL when replaceState is called after a pushState.
     GURL url = params.url;
     bool needs_update = false;
     BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
@@ skipping 19 matching lines @@
   new_entry->SetPostID(params.post_id);
   new_entry->SetOriginalRequestURL(params.original_request_url);
   new_entry->SetIsOverridingUserAgent(params.is_overriding_user_agent);
 
   InsertOrReplaceEntry(new_entry, replace_entry);
 }
 
 void NavigationControllerImpl::RendererDidNavigateToExistingPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // We should only get here for main frame navigations.
-  DCHECK(content::PageTransitionIsMainFrame(params.transition));
+  DCHECK(PageTransitionIsMainFrame(params.transition));
 
   // This is a back/forward navigation. The existing page for the ID is
   // guaranteed to exist by ClassifyNavigation, and we just need to update it
   // with new information from the renderer.
   int entry_index = GetEntryIndexWithPageID(web_contents_->GetSiteInstance(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
   NavigationEntryImpl* entry = entries_[entry_index].get();
 
@@ skipping 45 matching lines @@
   // The URL may have changed due to redirects.
   if (existing_entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(existing_entry, params.url);
   existing_entry->SetURL(params.url);
 
   DiscardNonCommittedEntries();
 }
 
 void NavigationControllerImpl::RendererDidNavigateInPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
-  DCHECK(content::PageTransitionIsMainFrame(params.transition)) <<
+  DCHECK(PageTransitionIsMainFrame(params.transition)) <<
       "WebKit should only tell us about in-page navs for the main frame.";
   // We're guaranteed to have an entry for this one.
   NavigationEntryImpl* existing_entry = GetEntryWithPageID(
       web_contents_->GetSiteInstance(), params.page_id);
 
   // Reference fragment navigation. We're guaranteed to have the last_committed
   // entry and it will be the same page as the new navigation (minus the
   // reference fragments, of course).  We'll update the URL of the existing
   // entry without pruning the forward history.
   existing_entry->SetURL(params.url);
   if (existing_entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(existing_entry, params.url);
 
   // This replaces the existing entry since the page ID didn't change.
   *did_replace_entry = true;
 
   if (pending_entry_)
     DiscardNonCommittedEntriesInternal();
 
   // If a transient entry was removed, the indices might have changed, so we
   // have to query the entry index again.
   last_committed_entry_index_ =
       GetEntryIndexWithPageID(web_contents_->GetSiteInstance(), params.page_id);
 }
 
 void NavigationControllerImpl::RendererDidNavigateNewSubframe(
     const ViewHostMsg_FrameNavigate_Params& params) {
-  if (content::PageTransitionStripQualifier(params.transition) ==
-      content::PAGE_TRANSITION_AUTO_SUBFRAME) {
+  if (PageTransitionStripQualifier(params.transition) ==
+      PAGE_TRANSITION_AUTO_SUBFRAME) {
     // This is not user-initiated. Ignore.
     return;
   }
 
   // Manual subframe navigations just get the current entry cloned so the user
   // can go back or forward to it. The actual subframe information will be
   // stored in the page state for each of those entries. This happens out of
   // band with the actual navigations.
   DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
                                   << "that a last committed entry exists.";
@@ skipping 182 matching lines @@
     // Normally the interstitial page hides itself if the user doesn't proceeed.
     // This would result in showing a NavigationEntry we just removed. Set this
     // so the interstitial triggers a reload if the user doesn't proceed.
     static_cast<InterstitialPageImpl*>(web_contents_->GetInterstitialPage())->
         set_reload_on_dont_proceed(true);
   }
 }
 
 void NavigationControllerImpl::SetSessionStorageNamespace(
     const std::string& partition_id,
-    content::SessionStorageNamespace* session_storage_namespace) {
+    SessionStorageNamespace* session_storage_namespace) {
   if (!session_storage_namespace)
     return;
 
   // We can't overwrite an existing SessionStorage without violating spec.
   // Attempts to do so may give a tab access to another tab's session storage
   // so die hard on an error.
   bool successful_insert = session_storage_namespace_map_.insert(
       make_pair(partition_id,
                 static_cast<SessionStorageNamespaceImpl*>(
                     session_storage_namespace)))
           .second;
   CHECK(successful_insert) << "Cannot replace existing SessionStorageNamespace";
 }
 
 void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
   max_restored_page_id_ = max_id;
 }
 
 int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
   return max_restored_page_id_;
 }
 
 SessionStorageNamespace*
-NavigationControllerImpl::GetSessionStorageNamespace(
-    content::SiteInstance* instance) {
+NavigationControllerImpl::GetSessionStorageNamespace(SiteInstance* instance) {
   std::string partition_id;
   if (instance) {
     // TODO(ajwong): When GetDefaultSessionStorageNamespace() goes away, remove
     // this if statement so |instance| must not be NULL.
     partition_id =
         GetContentClient()->browser()->GetStoragePartitionIdForSite(
             browser_context_, instance->GetSiteURL());
   }
 
   SessionStorageNamespaceMap::const_iterator it =
       session_storage_namespace_map_.find(partition_id);
   if (it != session_storage_namespace_map_.end())
     return it->second.get();
 
   // Create one if no one has accessed session storage for this partition yet.
   //
   // TODO(ajwong): Should this use the |partition_id| directly rather than
   // re-lookup via |instance|?  http://crbug.com/142685
-  content::StoragePartition* partition =
+  StoragePartition* partition =
               BrowserContext::GetStoragePartition(browser_context_, instance);
   SessionStorageNamespaceImpl* session_storage_namespace =
       new SessionStorageNamespaceImpl(
           static_cast<DOMStorageContextImpl*>(
               partition->GetDOMStorageContext()));
   session_storage_namespace_map_[partition_id] = session_storage_namespace;
 
   return session_storage_namespace;
 }
 
@@ skipping 37 matching lines @@
 NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
   return pending_entry_;
 }
 
 int NavigationControllerImpl::GetPendingEntryIndex() const {
   return pending_entry_index_;
 }
 
 void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry,
                                                     bool replace) {
-  DCHECK(entry->GetTransitionType() != content::PAGE_TRANSITION_AUTO_SUBFRAME);
+  DCHECK(entry->GetTransitionType() != PAGE_TRANSITION_AUTO_SUBFRAME);
 
   // Copy the pending entry's unique ID to the committed entry.
   // I don't know if pending_entry_index_ can be other than -1 here.
   const NavigationEntryImpl* const pending_entry =
       (pending_entry_index_ == -1) ?
           pending_entry_ : entries_[pending_entry_index_].get();
   if (pending_entry)
     entry->set_unique_id(pending_entry->GetUniqueID());
 
   DiscardNonCommittedEntriesInternal();
@@ skipping 44 matching lines @@
   // a session history navigation to the last committed page, RenderViewHost
   // will force the throbber to start, but WebKit will essentially ignore the
   // navigation, and won't send a message to stop the throbber. To prevent this
   // from happening, we drop the navigation here and stop the slow-to-commit
   // page from loading (which would normally happen during the navigation).
   if (pending_entry_index_ != -1 &&
       pending_entry_index_ == last_committed_entry_index_ &&
       (entries_[pending_entry_index_]->restore_type() ==
           NavigationEntryImpl::RESTORE_NONE) &&
       (entries_[pending_entry_index_]->GetTransitionType() &
-          content::PAGE_TRANSITION_FORWARD_BACK)) {
+          PAGE_TRANSITION_FORWARD_BACK)) {
     web_contents_->Stop();
 
     // If an interstitial page is showing, we want to close it to get back
     // to what was showing before.
     if (web_contents_->GetInterstitialPage())
       web_contents_->GetInterstitialPage()->DontProceed();
 
     DiscardNonCommittedEntries();
     return;
   }
@@ skipping 22 matching lines @@
   // navigations to restored entries in WebContentsImpl::OnGoToEntryAtOffset.
   if (pending_entry_ && !pending_entry_->site_instance() &&
       pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
     pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>(
         web_contents_->GetPendingSiteInstance()));
     pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
   }
 }
 
 void NavigationControllerImpl::NotifyNavigationEntryCommitted(
-    content::LoadCommittedDetails* details) {
+    LoadCommittedDetails* details) {
   details->entry = GetActiveEntry();
-  content::NotificationDetails notification_details =
-      content::Details<content::LoadCommittedDetails>(details);
+  NotificationDetails notification_details =
+      Details<LoadCommittedDetails>(details);
 
   // We need to notify the ssl_manager_ before the web_contents_ so the
   // location bar will have up-to-date information about the security style
   // when it wants to draw.  See http://crbug.com/11157
   ssl_manager_.DidCommitProvisionalLoad(notification_details);
 
   // TODO(pkasting): http://b/1113079 Probably these explicit notification paths
   // should be removed, and interested parties should just listen for the
   // notification below instead.
   web_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<NavigationController>(this),
+  NotificationService::current()->Notify(
+      NOTIFICATION_NAV_ENTRY_COMMITTED,
+      Source<NavigationController>(this),
       notification_details);
 }
 
 // static
 size_t NavigationControllerImpl::max_entry_count() {
   if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet)
      return max_entry_count_for_testing_;
-  return content::kMaxSessionHistoryEntries;
+  return kMaxSessionHistoryEntries;
 }
 
 void NavigationControllerImpl::SetActive(bool is_active) {
   if (is_active && needs_reload_)
     LoadIfNecessary();
 }
 
 void NavigationControllerImpl::LoadIfNecessary() {
   if (!needs_reload_)
     return;
 
   // Calling Reload() results in ignoring state, and not loading.
   // Explicitly use NavigateToPendingEntry so that the renderer uses the
   // cached state.
   pending_entry_index_ = last_committed_entry_index_;
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::NotifyEntryChanged(const NavigationEntry* entry,
                                                   int index) {
-  content::EntryChangedDetails det;
+  EntryChangedDetails det;
   det.changed_entry = entry;
   det.index = index;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_NAV_ENTRY_CHANGED,
-      content::Source<NavigationController>(this),
-      content::Details<content::EntryChangedDetails>(&det));
+  NotificationService::current()->Notify(
+      NOTIFICATION_NAV_ENTRY_CHANGED,
+      Source<NavigationController>(this),
+      Details<EntryChangedDetails>(&det));
 }
 
 void NavigationControllerImpl::FinishRestore(int selected_index,
                                              RestoreType type) {
   DCHECK(selected_index >= 0 && selected_index < GetEntryCount());
   ConfigureEntriesForRestore(&entries_, type);
 
   SetMaxRestoredPageID(static_cast<int32>(GetEntryCount()));
 
   last_committed_entry_index_ = selected_index;
@@ skipping 34 matching lines @@
 }
 
 void NavigationControllerImpl::InsertEntriesFrom(
     const NavigationControllerImpl& source,
     int max_index) {
   DCHECK_LE(max_index, source.GetEntryCount());
   size_t insert_index = 0;
   for (int i = 0; i < max_index; i++) {
     // When cloning a tab, copy all entries except interstitial pages
     if (source.entries_[i].get()->GetPageType() !=
-        content::PAGE_TYPE_INTERSTITIAL) {
+        PAGE_TYPE_INTERSTITIAL) {
       entries_.insert(entries_.begin() + insert_index++,
                       linked_ptr<NavigationEntryImpl>(
                           new NavigationEntryImpl(*source.entries_[i])));
     }
   }
 }
 
 void NavigationControllerImpl::SetGetTimestampCallbackForTest(
     const base::Callback<base::Time()>& get_timestamp_callback) {
   get_timestamp_callback_ = get_timestamp_callback;
 }
+
+}  // namespace content