Rename NavigationController to NavigationControllerImpl and put it into the content namespace. Al...

content/browser/tab_contents/navigation_controller.cc

 // Copyright (c) 2011 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/tab_contents/navigation_controller.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"  // Temporary
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_url_handler.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/renderer_host/render_view_host.h"  // Temporary
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/interstitial_page.h"
-#include "content/browser/tab_contents/navigation_entry.h"
+#include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_constants.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::GlobalRequestID;
+using content::NavigationEntry;
+using content::NavigationEntryImpl;
 using content::UserMetricsAction;
 
 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(NavigationController* nav_controller,
                          bool from_front,
                          int count) {
   content::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));
 }
 
 // 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(NavigationEntry* entry) {
+void SetContentStateIfEmpty(NavigationEntryImpl* entry) {
   if (entry->GetContentState().empty()) {
     entry->SetContentState(
         webkit_glue::CreateHistoryStateForURL(entry->GetURL()));
   }
 }
 
 // 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<NavigationEntry> >* entries,
+    std::vector<linked_ptr<NavigationEntryImpl> >* entries,
     bool from_last_session) {
   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]->set_restore_type(from_last_session ?
-        NavigationEntry::RESTORE_LAST_SESSION :
-        NavigationEntry::RESTORE_CURRENT_SESSION);
+        NavigationEntryImpl::RESTORE_LAST_SESSION :
+        NavigationEntryImpl::RESTORE_CURRENT_SESSION);
     // 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) {
   if (existing_url == new_url || !new_url.has_ref()) {
     // TODO(jcampan): what about when navigating back from a ref URL to the top
     // non ref URL? Nothing is loaded in that case but we return false here.
@@ skipping 50 matching lines @@
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSED,
       content::Source<NavigationController>(this),
       content::NotificationService::NoDetails());
 }
 
 void NavigationController::Restore(
     int selected_navigation,
     bool from_last_session,
-    std::vector<content::NavigationEntry*>* entries) {
+    std::vector<NavigationEntry*>* entries) {
   // Verify that this controller is unused and that the input is valid.
   DCHECK(entry_count() == 0 && !GetPendingEntry());
   DCHECK(selected_navigation >= 0 &&
          selected_navigation < static_cast<int>(entries->size()));
 
   needs_reload_ = true;
   for (size_t i = 0; i < entries->size(); ++i) {
-    NavigationEntry* entry =
-        NavigationEntry::FromNavigationEntry((*entries)[i]);
-    entries_.push_back(linked_ptr<NavigationEntry>(entry));
+    NavigationEntryImpl* entry =
+        NavigationEntryImpl::FromNavigationEntry((*entries)[i]);
+    entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
   }
   entries->clear();
 
   // And finish the restore.
   FinishRestore(selected_navigation, from_last_session);
 }
 
 void NavigationController::Reload(bool check_for_repost) {
   ReloadInternal(check_for_repost, RELOAD);
 }
@@ skipping 50 matching lines @@
     ReloadInternal(false, pending_reload_);
     pending_reload_ = NO_RELOAD;
   }
 }
 
 bool NavigationController::IsInitialNavigation() {
   return last_document_loaded_.is_null();
 }
 
 // static
-content::NavigationEntry* NavigationController::CreateNavigationEntry(
+NavigationEntry* NavigationController::CreateNavigationEntry(
       const GURL& url,
       const content::Referrer& referrer,
       content::PageTransition transition,
       bool is_renderer_initiated,
       const std::string& extra_headers,
       content::BrowserContext* browser_context) {
   return CreateNavigationEntryImpl(
       url, referrer, transition, is_renderer_initiated, extra_headers,
       browser_context);
 }
 
 // static
-NavigationEntry* NavigationController::CreateNavigationEntryImpl(
+NavigationEntryImpl* NavigationController::CreateNavigationEntryImpl(
     const GURL& url, const content::Referrer& referrer,
     content::PageTransition transition,
     bool is_renderer_initiated, const std::string& extra_headers,
     content::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
   // will actually be loaded. This real URL won't be shown to the user, just
   // used internally.
   GURL loaded_url(url);
   bool reverse_on_redirect = false;
   BrowserURLHandler::GetInstance()->RewriteURLIfNecessary(
       &loaded_url, browser_context, &reverse_on_redirect);
 
-  NavigationEntry* entry = new NavigationEntry(
+  NavigationEntryImpl* entry = new NavigationEntryImpl(
       NULL,  // The site instance for tabs is sent on navigation
              // (TabContents::GetSiteInstance).
       -1,
       loaded_url,
       referrer,
       string16(),
       transition,
       is_renderer_initiated);
   entry->SetVirtualURL(url);
   entry->set_user_typed_url(url);
   entry->set_update_virtual_url_with_url(reverse_on_redirect);
   entry->set_extra_headers(extra_headers);
   return entry;
 }
 
-NavigationEntry* NavigationController::GetEntryWithPageID(
+NavigationEntryImpl* NavigationController::GetEntryWithPageID(
     SiteInstance* instance, int32 page_id) const {
   int index = GetEntryIndexWithPageID(instance, page_id);
   return (index != -1) ? entries_[index].get() : NULL;
 }
 
-void NavigationController::LoadEntry(NavigationEntry* entry) {
+void NavigationController::LoadEntry(NavigationEntryImpl* entry) {
   // Don't navigate to URLs disabled by policy. This prevents showing the URL
   // on the Omnibar when it is also going to be blocked by
   // ChildProcessSecurityPolicy::CanRequestURL.
   ChildProcessSecurityPolicy *policy =
       ChildProcessSecurityPolicy::GetInstance();
   if (policy->IsDisabledScheme(entry->GetURL().scheme()) ||
       policy->IsDisabledScheme(entry->GetVirtualURL().scheme())) {
     VLOG(1) << "URL not loaded because the scheme is blocked by policy: "
             << 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<content::NavigationEntry>(entry));
+      content::Details<NavigationEntry>(entry));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
-content::NavigationEntry* NavigationController::GetActiveEntry() const {
+NavigationEntry* NavigationController::GetActiveEntry() const {
   if (transient_entry_index_ != -1)
     return entries_[transient_entry_index_].get();
   if (pending_entry_)
     return pending_entry_;
   return GetLastCommittedEntry();
 }
 
-content::NavigationEntry* NavigationController::GetVisibleEntry() const {
+NavigationEntry* NavigationController::GetVisibleEntry() const {
   if (transient_entry_index_ != -1)
     return entries_[transient_entry_index_].get();
   // Only return the pending_entry for new (non-history), browser-initiated
   // navigations, in order to prevent URL spoof attacks.
   // Ideally we would also show the pending entry's URL for new renderer-
   // initiated navigations with no last committed entry (e.g., a link opening
   // in a new tab), but an attacker can insert content into the about:blank
   // page while the pending URL loads in that case.
   if (pending_entry_ &&
       pending_entry_->GetPageID() == -1 &&
       !pending_entry_->is_renderer_initiated())
     return pending_entry_;
   return GetLastCommittedEntry();
 }
 
 int NavigationController::GetCurrentEntryIndex() const {
   if (transient_entry_index_ != -1)
     return transient_entry_index_;
   if (pending_entry_index_ != -1)
     return pending_entry_index_;
   return last_committed_entry_index_;
 }
 
-content::NavigationEntry* NavigationController::GetLastCommittedEntry() const {
+NavigationEntry* NavigationController::GetLastCommittedEntry() const {
   if (last_committed_entry_index_ == -1)
     return NULL;
   return entries_[last_committed_entry_index_].get();
 }
 
 bool NavigationController::CanViewSource() const {
   bool is_supported_mime_type = net::IsSupportedNonImageMimeType(
       tab_contents_->GetContentsMimeType().c_str());
-  content::NavigationEntry* active_entry = GetActiveEntry();
+  NavigationEntry* active_entry = GetActiveEntry();
   return active_entry && !active_entry->IsViewSourceMode() &&
     is_supported_mime_type && !tab_contents_->GetInterstitialPage();
 }
 
-content::NavigationEntry* NavigationController::GetEntryAtIndex(
+NavigationEntry* NavigationController::GetEntryAtIndex(
     int index) const {
   return entries_.at(index).get();
 }
 
-content::NavigationEntry* NavigationController::GetEntryAtOffset(
+NavigationEntry* NavigationController::GetEntryAtOffset(
     int offset) const {
   int index = (transient_entry_index_ != -1) ?
                   transient_entry_index_ + offset :
                   last_committed_entry_index_ + offset;
   if (index < 0 || index >= entry_count())
     return NULL;
 
   return entries_[index].get();
 }
 
@@ skipping 89 matching lines @@
 }
 
 void NavigationController::RemoveEntryAtIndex(int index) {
   if (index == last_committed_entry_index_)
     return;
 
   RemoveEntryAtIndexInternal(index);
 }
 
 void NavigationController::UpdateVirtualURLToURL(
-    NavigationEntry* entry, const GURL& new_url) {
+    NavigationEntryImpl* entry, const GURL& new_url) {
   GURL new_virtual_url(new_url);
   if (BrowserURLHandler::GetInstance()->ReverseURLRewrite(
           &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
     entry->SetVirtualURL(new_virtual_url);
   }
 }
 
-void NavigationController::AddTransientEntry(NavigationEntry* entry) {
+void NavigationController::AddTransientEntry(NavigationEntryImpl* entry) {
   // Discard any current transient entry, we can only have one at a time.
   int index = 0;
   if (last_committed_entry_index_ != -1)
     index = last_committed_entry_index_ + 1;
   DiscardTransientEntry();
-  entries_.insert(entries_.begin() + index, linked_ptr<NavigationEntry>(entry));
+  entries_.insert(
+      entries_.begin() + index, linked_ptr<NavigationEntryImpl>(entry));
   transient_entry_index_ = index;
   tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 }
 
 void NavigationController::TransferURL(
     const GURL& url,
     const content::Referrer& referrer,
     content::PageTransition transition,
     const std::string& extra_headers,
     const GlobalRequestID& transferred_global_request_id,
     bool is_renderer_initiated) {
   // The user initiated a load, we don't need to reload anymore.
   needs_reload_ = false;
 
-  NavigationEntry* entry = CreateNavigationEntryImpl(url, referrer, transition,
-                                                     is_renderer_initiated,
-                                                     extra_headers,
-                                                     browser_context_);
+  NavigationEntryImpl* entry = CreateNavigationEntryImpl(
+      url, referrer, transition, is_renderer_initiated, extra_headers,
+      browser_context_);
   entry->set_transferred_global_request_id(transferred_global_request_id);
 
   LoadEntry(entry);
 }
 
 void NavigationController::LoadURL(
     const GURL& url,
     const content::Referrer& referrer,
     content::PageTransition transition,
     const std::string& extra_headers) {
   // The user initiated a load, we don't need to reload anymore.
   needs_reload_ = false;
 
-  NavigationEntry* entry = CreateNavigationEntryImpl(url, referrer, transition,
-                                                     false,
-                                                     extra_headers,
-                                                     browser_context_);
+  NavigationEntryImpl* entry = CreateNavigationEntryImpl(
+      url, referrer, transition, false, extra_headers, browser_context_);
 
   LoadEntry(entry);
 }
 
 void NavigationController::LoadURLFromRenderer(
     const GURL& url,
     const content::Referrer& referrer,
     content::PageTransition transition,
     const std::string& extra_headers) {
   // The user initiated a load, we don't need to reload anymore.
   needs_reload_ = false;
 
-  NavigationEntry* entry = CreateNavigationEntryImpl(url, referrer, transition,
-                                                     true,
-                                                     extra_headers,
-                                                     browser_context_);
+  NavigationEntryImpl* entry = CreateNavigationEntryImpl(
+      url, referrer, transition, true, extra_headers, browser_context_);
 
   LoadEntry(entry);
 }
 
 void NavigationController::DocumentLoadedInFrame() {
   last_document_loaded_ = base::TimeTicks::Now();
 }
 
 bool NavigationController::RendererDidNavigate(
     const ViewHostMsg_FrameNavigate_Params& params,
@@ skipping 50 matching lines @@
             TabContents::INVALIDATE_URL);
       }
       return false;
     default:
       NOTREACHED();
   }
 
   // All committed entries should have nonempty content state so WebKit doesn't
   // get confused when we go back to them (see the function for details).
   DCHECK(!params.content_state.empty());
-  NavigationEntry* active_entry =
-      NavigationEntry::FromNavigationEntry(GetActiveEntry());
+  NavigationEntryImpl* active_entry =
+      NavigationEntryImpl::FromNavigationEntry(GetActiveEntry());
   active_entry->SetContentState(params.content_state);
 
   // 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() == tab_contents_->GetSiteInstance());
 
   // Now prep the rest of the details for the notification and broadcast.
@@ skipping 87 matching lines @@
       else
         temp.append("N");
       if (entries_[i]->site_instance() != tab_contents_->GetSiteInstance())
         temp.append("x");
       temp.append(",");
     }
     GURL url(temp);
     tab_contents_->GetRenderViewHost()->Send(new ViewMsg_TempCrashWithData(url));
     return content::NAVIGATION_TYPE_NAV_IGNORE;
   }
-  NavigationEntry* existing_entry = entries_[existing_entry_index].get();
+  NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
 
   if (!content::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;
   }
 
   // Anything below here we know is a main frame navigation.
@@ skipping 29 matching lines @@
   // For main frame transition, we judge by params.transition.
   // Otherwise, by params.redirects.
   if (content::PageTransitionIsMainFrame(params.transition)) {
     return content::PageTransitionIsRedirect(params.transition);
   }
   return params.redirects.size() > 1;
 }
 
 void NavigationController::RendererDidNavigateToNewPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
-  NavigationEntry* new_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 NavigationEntry(*pending_entry_);
+    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);
     update_virtual_url = new_entry->update_virtual_url_with_url();
   } else {
-    new_entry = new NavigationEntry;
+    new_entry = new NavigationEntryImpl;
     // When navigating to a new page, give the browser URL handler a chance to
     // update the virtual URL based on the new URL. For example, this is needed
     // to show chrome://bookmarks/#1 when the bookmarks webui extension changes
     // the URL.
     update_virtual_url = true;
   }
 
   new_entry->SetURL(params.url);
   if (update_virtual_url)
     UpdateVirtualURLToURL(new_entry, params.url);
@@ skipping 11 matching lines @@
   // We should only get here for main frame navigations.
   DCHECK(content::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(tab_contents_->GetSiteInstance(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
-  NavigationEntry* entry = entries_[entry_index].get();
+  NavigationEntryImpl* entry = entries_[entry_index].get();
 
   // The URL may have changed due to redirects. The site instance will normally
   // be the same except during session restore, when no site instance will be
   // assigned.
   entry->SetURL(params.url);
   if (entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(entry, params.url);
   DCHECK(entry->site_instance() == NULL ||
          entry->site_instance() == tab_contents_->GetSiteInstance());
   entry->set_site_instance(tab_contents_->GetSiteInstance());
@@ skipping 16 matching lines @@
   // have to query the entry index again.
   last_committed_entry_index_ =
       GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
 }
 
 void NavigationController::RendererDidNavigateToSamePage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // This mode implies we have a pending entry that's the same as an existing
   // entry for this page ID. This entry is guaranteed to exist by
   // ClassifyNavigation. All we need to do is update the existing entry.
-  NavigationEntry* existing_entry = GetEntryWithPageID(
-      tab_contents_->GetSiteInstance(),
-      params.page_id);
+  NavigationEntryImpl* existing_entry = GetEntryWithPageID(
+      tab_contents_->GetSiteInstance(), params.page_id);
 
   // We assign the entry's unique ID to be that of the new one. Since this is
   // always the result of a user action, we want to dismiss infobars, etc. like
   // a regular user-initiated navigation.
   existing_entry->set_unique_id(pending_entry_->GetUniqueID());
 
   // 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 NavigationController::RendererDidNavigateInPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
   DCHECK(content::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.
-  NavigationEntry* existing_entry = GetEntryWithPageID(
-      tab_contents_->GetSiteInstance(),
-      params.page_id);
+  NavigationEntryImpl* existing_entry = GetEntryWithPageID(
+      tab_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.
@@ skipping 15 matching lines @@
     // 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.";
-  NavigationEntry* new_entry = new NavigationEntry(
-      *NavigationEntry::FromNavigationEntry(GetLastCommittedEntry()));
+  NavigationEntryImpl* new_entry = new NavigationEntryImpl(
+      *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()));
   new_entry->SetPageID(params.page_id);
   InsertOrReplaceEntry(new_entry, false);
 }
 
 bool NavigationController::RendererDidNavigateAutoSubframe(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // We're guaranteed to have a previously committed entry, and we now need to
   // handle navigation inside of a subframe in it without creating a new entry.
   DCHECK(GetLastCommittedEntry());
 
@@ skipping 11 matching lines @@
 
   // Update the current navigation entry in case we're going back/forward.
   if (entry_index != last_committed_entry_index_) {
     last_committed_entry_index_ = entry_index;
     return true;
   }
   return false;
 }
 
 int NavigationController::GetIndexOfEntry(
-    const NavigationEntry* entry) const {
+    const NavigationEntryImpl* entry) const {
   const NavigationEntries::const_iterator i(std::find(
       entries_.begin(),
       entries_.end(),
       entry));
   return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin());
 }
 
 bool NavigationController::IsURLInPageNavigation(const GURL& url) const {
-  content::NavigationEntry* last_committed = GetLastCommittedEntry();
+  NavigationEntry* last_committed = GetLastCommittedEntry();
   if (!last_committed)
     return false;
   return AreURLsInPageNavigation(last_committed->GetURL(), url);
 }
 
 void NavigationController::CopyStateFrom(const NavigationController& source) {
   // Verify that we look new.
   DCHECK(entry_count() == 0 && !GetPendingEntry());
 
   if (source.entry_count() == 0)
     return;  // Nothing new to do.
 
   needs_reload_ = true;
   InsertEntriesFrom(source, source.entry_count());
 
   session_storage_namespace_ = source.session_storage_namespace_->Clone();
 
   FinishRestore(source.last_committed_entry_index_, false);
 }
 
 void NavigationController::CopyStateFromAndPrune(NavigationController* source) {
   // The SiteInstance and page_id of the last committed entry needs to be
   // remembered at this point, in case there is only one committed entry
   // and it is pruned.
-  NavigationEntry* last_committed =
-      NavigationEntry::FromNavigationEntry(GetLastCommittedEntry());
+  NavigationEntryImpl* last_committed =
+      NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry());
   SiteInstance* site_instance =
       last_committed ? last_committed->site_instance() : NULL;
   int32 minimum_page_id = last_committed ? last_committed->GetPageID() : -1;
 
   // This code is intended for use when the last entry is the active entry.
   DCHECK((transient_entry_index_ != -1 &&
           transient_entry_index_ == entry_count() - 1) ||
          (pending_entry_ && (pending_entry_index_ == -1 ||
                              pending_entry_index_ == entry_count() - 1)) ||
          (!pending_entry_ && last_committed_entry_index_ == entry_count() - 1));
@@ skipping 81 matching lines @@
   bool transient = transient_entry_index_ != -1;
   DiscardNonCommittedEntriesInternal();
 
   // If there was a transient entry, invalidate everything so the new active
   // entry state is shown.
   if (transient) {
     tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
   }
 }
 
-content::NavigationEntry* NavigationController::GetPendingEntry() const {
+NavigationEntry* NavigationController::GetPendingEntry() const {
   return pending_entry_;
 }
 
-void NavigationController::InsertOrReplaceEntry(NavigationEntry* entry,
+void NavigationController::InsertOrReplaceEntry(NavigationEntryImpl* entry,
                                                 bool replace) {
   DCHECK(entry->GetTransitionType() != content::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 NavigationEntry* const pending_entry = (pending_entry_index_ == -1) ?
-      pending_entry_ : entries_[pending_entry_index_].get();
+  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();
 
   int current_size = static_cast<int>(entries_.size());
 
   if (current_size > 0) {
     // Prune any entries which are in front of the current entry.
     // Also prune the current entry if we are to replace the current entry.
@@ skipping 12 matching lines @@
     if (num_pruned > 0)  // Only notify if we did prune something.
       NotifyPrunedEntries(this, false, num_pruned);
   }
 
   if (entries_.size() >= max_entry_count()) {
     DCHECK(last_committed_entry_index_ > 0);
     RemoveEntryAtIndex(0);
     NotifyPrunedEntries(this, true, 1);
   }
 
-  entries_.push_back(linked_ptr<NavigationEntry>(entry));
+  entries_.push_back(linked_ptr<NavigationEntryImpl>(entry));
   last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1;
 
   // This is a new page ID, so we need everybody to know about it.
   tab_contents_->UpdateMaxPageID(entry->GetPageID());
 }
 
 void NavigationController::NavigateToPendingEntry(ReloadType reload_type) {
   needs_reload_ = false;
 
   // If we were navigating to a slow-to-commit page, and the user performs
   // 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() ==
-          NavigationEntry::RESTORE_NONE) &&
+          NavigationEntryImpl::RESTORE_NONE) &&
       (entries_[pending_entry_index_]->GetTransitionType() &
           content::PAGE_TRANSITION_FORWARD_BACK)) {
     tab_contents_->Stop();
 
     // If an interstitial page is showing, we want to close it to get back
     // to what was showing before.
     if (tab_contents_->GetInterstitialPage())
       tab_contents_->GetInterstitialPage()->DontProceed();
 
     DiscardNonCommittedEntries();
@@ skipping 14 matching lines @@
   }
 
   if (!tab_contents_->NavigateToPendingEntry(reload_type))
     DiscardNonCommittedEntries();
 
   // If the entry is being restored and doesn't have a SiteInstance yet, fill
   // it in now that we know. This allows us to find the entry when it commits.
   // This works for browser-initiated navigations. We handle renderer-initiated
   // navigations to restored entries in TabContents::OnGoToEntryAtOffset.
   if (pending_entry_ && !pending_entry_->site_instance() &&
-      pending_entry_->restore_type() != NavigationEntry::RESTORE_NONE) {
+      pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
     pending_entry_->set_site_instance(tab_contents_->GetPendingSiteInstance());
-    pending_entry_->set_restore_type(NavigationEntry::RESTORE_NONE);
+    pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE);
   }
 }
 
 void NavigationController::NotifyNavigationEntryCommitted(
     content::LoadCommittedDetails* details) {
   details->entry = GetActiveEntry();
   content::NotificationDetails notification_details =
       content::Details<content::LoadCommittedDetails>(details);
 
   // We need to notify the ssl_manager_ before the tab_contents_ so the
@@ skipping 33 matching lines @@
   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 NavigationController::NotifyEntryChanged(
-    const content::NavigationEntry* entry, int index) {
+void NavigationController::NotifyEntryChanged(const NavigationEntry* entry,
+                                              int index) {
   content::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));
 }
 
 void NavigationController::FinishRestore(int selected_index,
@@ skipping 27 matching lines @@
 int NavigationController::GetEntryIndexWithPageID(
     SiteInstance* instance, int32 page_id) const {
   for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) {
     if ((entries_[i]->site_instance() == instance) &&
         (entries_[i]->GetPageID() == page_id))
       return i;
   }
   return -1;
 }
 
-content::NavigationEntry* NavigationController::GetTransientEntry() const {
+NavigationEntry* NavigationController::GetTransientEntry() const {
   if (transient_entry_index_ == -1)
     return NULL;
   return entries_[transient_entry_index_].get();
 }
 
 void NavigationController::InsertEntriesFrom(
     const NavigationController& source,
     int max_index) {
   DCHECK_LE(max_index, source.entry_count());
   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) {
       entries_.insert(entries_.begin() + insert_index++,
-                      linked_ptr<NavigationEntry>(
-                          new NavigationEntry(*source.entries_[i])));
+                      linked_ptr<NavigationEntryImpl>(
+                          new NavigationEntryImpl(*source.entries_[i])));
     }
   }
 }