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

content/browser/tab_contents/tab_contents.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/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 10 matching lines @@
 #include "content/browser/intents/web_intents_dispatcher_impl.h"
 #include "content/browser/load_from_memory_cache_details.h"
 #include "content/browser/load_notification_details.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #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/provisional_load_details.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/browser/tab_contents/title_updated_details.h"
 #include "content/browser/webui/web_ui_factory.h"
 #include "content/common/intents_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/download_manager.h"
@@ skipping 63 matching lines @@
 // In this case the old RVH has been swapped out but the new one has not
 // replaced it, yet. Therefore, we cancel the pending RVH and skip the unloading
 // of the old RVH.
 
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::DevToolsManagerImpl;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::GlobalRequestID;
+using content::NavigationEntry;
+using content::NavigationEntryImpl;
 using content::OpenURLParams;
 using content::SSLStatus;
 using content::UserMetricsAction;
 using content::WebContents;
 using content::WebContentsObserver;
 
 namespace {
 
 // Amount of time we wait between when a key event is received and the renderer
 // is queried for its state and pushed to the NavigationEntry.
 const int kQueryStateDelay = 5000;
 
 const int kSyncWaitDelay = 40;
 
 static const char kDotGoogleDotCom[] = ".google.com";
 
 #if defined(OS_WIN)
 
 BOOL CALLBACK InvalidateWindow(HWND hwnd, LPARAM lparam) {
   // Note: erase is required to properly paint some widgets borders. This can
   // be seen with textfields.
   InvalidateRect(hwnd, NULL, TRUE);
   return TRUE;
 }
 #endif
 
 ViewMsg_Navigate_Type::Value GetNavigationType(
-    content::BrowserContext* browser_context, const NavigationEntry& entry,
+    content::BrowserContext* browser_context, const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type) {
   switch (reload_type) {
     case NavigationController::RELOAD:
       return ViewMsg_Navigate_Type::RELOAD;
     case NavigationController::RELOAD_IGNORING_CACHE:
       return ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
     case NavigationController::NO_RELOAD:
       break;  // Fall through to rest of function.
   }
 
-  if (entry.restore_type() == NavigationEntry::RESTORE_LAST_SESSION &&
+  if (entry.restore_type() == NavigationEntryImpl::RESTORE_LAST_SESSION &&
       browser_context->DidLastSessionExitCleanly())
     return ViewMsg_Navigate_Type::RESTORE;
 
   return ViewMsg_Navigate_Type::NORMAL;
 }
 
-void MakeNavigateParams(const NavigationEntry& entry,
+void MakeNavigateParams(const NavigationEntryImpl& entry,
                         const NavigationController& controller,
                         content::WebContentsDelegate* delegate,
                         NavigationController::ReloadType reload_type,
                         ViewMsg_Navigate_Params* params) {
   params->page_id = entry.GetPageID();
   params->pending_history_list_offset = controller.GetIndexOfEntry(&entry);
   params->current_history_list_offset = controller.last_committed_entry_index();
   params->current_history_list_length = controller.entry_count();
   params->url = entry.GetURL();
   params->referrer = entry.GetReferrer();
@@ skipping 194 matching lines @@
 void TabContents::SetViewType(content::ViewType type) {
   view_type_ = type;
 }
 
 content::ViewType TabContents::GetViewType() const {
   return view_type_;
 }
 
 const GURL& TabContents::GetURL() const {
   // We may not have a navigation entry yet
-  content::NavigationEntry* entry = controller_.GetActiveEntry();
+  NavigationEntry* entry = controller_.GetActiveEntry();
   return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
 }
 
 
 const base::PropertyBag* TabContents::GetPropertyBag() const {
   return &property_bag_;
 }
 
 base::PropertyBag* TabContents::GetPropertyBag() {
   return &property_bag_;
@@ skipping 38 matching lines @@
       : render_manager_.pending_web_ui();
 }
 
 WebUI* TabContents::GetCommittedWebUI() const {
   return render_manager_.web_ui();
 }
 
 const string16& TabContents::GetTitle() const {
   // Transient entries take precedence. They are used for interstitial pages
   // that are shown on top of existing pages.
-  content::NavigationEntry* entry = controller_.GetTransientEntry();
+  NavigationEntry* entry = controller_.GetTransientEntry();
   std::string accept_languages =
       content::GetContentClient()->browser()->GetAcceptLangs(
           GetBrowserContext());
   if (entry) {
     return entry->GetTitleForDisplay(accept_languages);
   }
   WebUI* our_web_ui = render_manager_.pending_web_ui() ?
       render_manager_.pending_web_ui() : render_manager_.web_ui();
   if (our_web_ui) {
     // Don't override the title in view source mode.
@@ skipping 327 matching lines @@
   // Notify observers.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidOpenURL(params.url, params.referrer,
                                params.disposition, params.transition));
   return new_contents;
 }
 
 bool TabContents::NavigateToPendingEntry(
     NavigationController::ReloadType reload_type) {
   return NavigateToEntry(
-      *NavigationEntry::FromNavigationEntry(controller_.GetPendingEntry()),
+      *NavigationEntryImpl::FromNavigationEntry(controller_.GetPendingEntry()),
       reload_type);
 }
 
 bool TabContents::NavigateToEntry(
-    const NavigationEntry& entry,
+    const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type) {
   // The renderer will reject IPC messages with URLs longer than
   // this limit, so don't attempt to navigate with a longer URL.
   if (entry.GetURL().spec().size() > content::kMaxURLChars)
     return false;
 
   RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
   if (!dest_render_view_host)
     return false;  // Unable to create the desired render view host.
 
@@ skipping 112 matching lines @@
 bool TabContents::SavePage(const FilePath& main_file, const FilePath& dir_path,
                            SavePackage::SavePackageType save_type) {
   // Stop the page from navigating.
   Stop();
 
   save_package_ = new SavePackage(this, save_type, main_file, dir_path);
   return save_package_->Init();
 }
 
 bool TabContents::IsActiveEntry(int32 page_id) {
-  NavigationEntry* active_entry =
-      NavigationEntry::FromNavigationEntry(controller_.GetActiveEntry());
+  NavigationEntryImpl* active_entry =
+      NavigationEntryImpl::FromNavigationEntry(controller_.GetActiveEntry());
   return (active_entry != NULL &&
           active_entry->site_instance() == GetSiteInstance() &&
           active_entry->GetPageID() == page_id);
 }
 
 const std::string& TabContents::GetContentsMimeType() const {
   return contents_mime_type_;
 }
 
 bool TabContents::WillNotifyDisconnection() const {
@@ skipping 60 matching lines @@
   HostZoomMap* zoom_map = GetBrowserContext()->GetHostZoomMap();
   if (!zoom_map)
     return 0;
 
   double zoom_level;
   if (temporary_zoom_settings_) {
     zoom_level = zoom_map->GetTemporaryZoomLevel(
         GetRenderProcessHost()->GetID(), GetRenderViewHost()->routing_id());
   } else {
     GURL url;
-    content::NavigationEntry* active_entry = GetController().GetActiveEntry();
+    NavigationEntry* active_entry = GetController().GetActiveEntry();
     // Since zoom map is updated using rewritten URL, use rewritten URL
     // to get the zoom level.
     url = active_entry ? active_entry->GetURL() : GURL::EmptyGURL();
     zoom_level = zoom_map->GetZoomLevel(net::GetHostOrSpecFromURL(url));
   }
   return zoom_level;
 }
 
 int TabContents::GetZoomPercent(bool* enable_increment,
                                 bool* enable_decrement) {
   *enable_decrement = *enable_increment = false;
   // Calculate the zoom percent from the factor. Round up to the nearest whole
   // number.
   int percent = static_cast<int>(
       WebKit::WebView::zoomLevelToZoomFactor(GetZoomLevel()) * 100 + 0.5);
   *enable_decrement = percent > minimum_zoom_percent_;
   *enable_increment = percent < maximum_zoom_percent_;
   return percent;
 }
 
 void TabContents::ViewSource() {
   if (!delegate_)
     return;
 
-  content::NavigationEntry* active_entry = GetController().GetActiveEntry();
+  NavigationEntry* active_entry = GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   delegate_->ViewSourceForTab(this, active_entry->GetURL());
 }
 
 void TabContents::ViewFrameSource(const GURL& url,
                                   const std::string& content_state) {
   if (!delegate_)
     return;
@@ skipping 60 matching lines @@
 
 bool TabContents::GotResponseToLockMouseRequest(bool allowed) {
   return GetRenderViewHost() ?
       GetRenderViewHost()->GotResponseToLockMouseRequest(allowed) : false;
 }
 
 bool TabContents::FocusLocationBarByDefault() {
   WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return web_ui->focus_location_bar_by_default();
-  content::NavigationEntry* entry = controller_.GetActiveEntry();
+  NavigationEntry* entry = controller_.GetActiveEntry();
   if (entry && entry->GetURL() == GURL(chrome::kAboutBlankURL))
     return true;
   return false;
 }
 
 void TabContents::SetFocusToLocationBar(bool select_all) {
   if (delegate_)
     delegate_->SetFocusToLocationBar(select_all);
 }
 
@@ skipping 37 matching lines @@
   }
 }
 
 void TabContents::OnDidRedirectProvisionalLoad(int32 page_id,
                                                const GURL& opener_url,
                                                const GURL& source_url,
                                                const GURL& target_url) {
   // TODO(creis): Remove this method and have the pre-rendering code listen to
   // the ResourceDispatcherHost's RESOURCE_RECEIVED_REDIRECT notification
   // instead.  See http://crbug.com/78512.
-  content::NavigationEntry* entry;
+  NavigationEntry* entry;
   if (page_id == -1)
     entry = controller_.GetPendingEntry();
   else
     entry = controller_.GetEntryWithPageID(GetSiteInstance(), page_id);
   if (!entry || entry->GetURL() != source_url)
     return;
 
   // Notify observers about the provisional change in the main frame URL.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     ProvisionalChangeToMainFrameUrl(target_url,
@@ skipping 145 matching lines @@
                                 error_code, error_description));
 }
 
 void TabContents::OnUpdateContentRestrictions(int restrictions) {
   content_restrictions_ = restrictions;
   delegate_->ContentRestrictionsChanged(this);
 }
 
 void TabContents::OnGoToEntryAtOffset(int offset) {
   if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
-    NavigationEntry* entry = NavigationEntry::FromNavigationEntry(
+    NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
         controller_.GetEntryAtOffset(offset));
     if (!entry)
       return;
     // Note that we don't call NavigationController::GotToOffset() as we don't
     // want to create a pending navigation entry (it might end up lingering
     // http://crbug.com/51680).
     entry->SetTransitionType(
         content::PageTransitionFromInt(
             entry->GetTransitionType() |
             content::PAGE_TRANSITION_FORWARD_BACK));
     NavigateToEntry(*entry, NavigationController::NO_RELOAD);
 
     // 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.
     if (!entry->site_instance() &&
-        entry->restore_type() != NavigationEntry::RESTORE_NONE) {
+        entry->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
       entry->set_site_instance(GetPendingSiteInstance());
     }
   }
 }
 
 void TabContents::OnUpdateZoomLimits(int minimum_percent,
                                      int maximum_percent,
                                      bool remember) {
   minimum_zoom_percent_ = minimum_percent;
   maximum_zoom_percent_ = maximum_percent;
@@ skipping 143 matching lines @@
   // sure the RenderView starts with a next_page_id_ larger than the number
   // of restored entries.  This must be called before the RenderView starts
   // navigating (to avoid a race between the browser updating max_page_id and
   // the renderer updating next_page_id_).  Because of this, we only call this
   // from CreateRenderView and allow that to notify the RenderView for us.
   int max_restored_page_id = controller_.max_restored_page_id();
   if (max_restored_page_id > GetMaxPageIDForSiteInstance(rvh->site_instance()))
     UpdateMaxPageIDForSiteInstance(rvh->site_instance(), max_restored_page_id);
 }
 
-bool TabContents::UpdateTitleForEntry(NavigationEntry* entry,
+bool TabContents::UpdateTitleForEntry(NavigationEntryImpl* entry,
                                       const string16& title) {
   // For file URLs without a title, use the pathname instead. In the case of a
   // synthesized title, we don't want the update to count toward the "one set
   // per page of the title to history."
   string16 final_title;
   bool explicit_set;
   if (entry && entry->GetURL().SchemeIsFile() && title.empty()) {
     final_title = UTF8ToUTF16(entry->GetURL().ExtractFileName());
     explicit_set = false;  // Don't count synthetic titles toward the set limit.
   } else {
@@ skipping 83 matching lines @@
 
 content::ViewType TabContents::GetRenderViewType() const {
   return view_type_;
 }
 
 void TabContents::RenderViewCreated(RenderViewHost* render_view_host) {
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
       content::Source<TabContents>(this),
       content::Details<RenderViewHost>(render_view_host));
-  content::NavigationEntry* entry = controller_.GetActiveEntry();
+  NavigationEntry* entry = controller_.GetActiveEntry();
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
   // use the pending Web UI rather than any possibly existing committed one.
   if (render_manager_.pending_web_ui())
     render_manager_.pending_web_ui()->RenderViewCreated(render_view_host);
 
   if (entry->IsViewSourceMode()) {
     // Put the renderer in view source mode.
@@ skipping 126 matching lines @@
   // We must be prepared to handle state updates for any page, these occur
   // when the user is scrolling and entering form data, as well as when we're
   // leaving a page, in which case our state may have already been moved to
   // the next page. The navigation controller will look up the appropriate
   // NavigationEntry and update it when it is notified via the delegate.
 
   int entry_index = controller_.GetEntryIndexWithPageID(
       rvh->site_instance(), page_id);
   if (entry_index < 0)
     return;
-  content::NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
+  NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
 
   if (state == entry->GetContentState())
     return;  // Nothing to update.
   entry->SetContentState(state);
   controller_.NotifyEntryChanged(entry, entry_index);
 }
 
 void TabContents::UpdateTitle(RenderViewHost* rvh,
                               int32 page_id,
                               const string16& title,
                               base::i18n::TextDirection title_direction) {
   // If we have a title, that's a pretty good indication that we've started
   // getting useful data.
   SetNotWaitingForResponse();
 
   DCHECK(rvh == GetRenderViewHost());
-  NavigationEntry* entry = controller_.GetEntryWithPageID(rvh->site_instance(),
-                                                          page_id);
+  NavigationEntryImpl* entry = controller_.GetEntryWithPageID(
+      rvh->site_instance(), page_id);
 
   // TODO(evan): make use of title_direction.
   // http://code.google.com/p/chromium/issues/detail?id=27094
   if (!UpdateTitleForEntry(entry, title))
     return;
 
   // Broadcast notifications when the UI should be updated.
   if (entry == controller_.GetEntryAtOffset(0))
     NotifyNavigationStateChanged(INVALIDATE_TITLE);
 }
@@ skipping 54 matching lines @@
       delegate_->ContentRestrictionsChanged(this);
   }
 
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidStartLoading());
 }
 
 void TabContents::DidStopLoading() {
   scoped_ptr<LoadNotificationDetails> details;
 
-  content::NavigationEntry* entry = controller_.GetActiveEntry();
+  NavigationEntry* entry = controller_.GetActiveEntry();
   // An entry may not exist for a stop when loading an initial blank page or
   // if an iframe injected by script into a blank page finishes loading.
   if (entry) {
     base::TimeDelta elapsed = base::TimeTicks::Now() - current_load_start_;
 
     details.reset(new LoadNotificationDetails(
         entry->GetVirtualURL(),
         entry->GetTransitionType(),
         elapsed,
         &controller_,
@@ skipping 289 matching lines @@
 }
 
 NavigationController& TabContents::GetControllerForRenderManager() {
   return GetController();
 }
 
 WebUI* TabContents::CreateWebUIForRenderManager(const GURL& url) {
   return content::WebUIFactory::Get()->CreateWebUIForURL(this, url);
 }
 
-content::NavigationEntry*
-TabContents::GetLastCommittedNavigationEntryForRenderManager() {
+NavigationEntry*
+    TabContents::GetLastCommittedNavigationEntryForRenderManager() {
   return controller_.GetLastCommittedEntry();
 }
 
 bool TabContents::CreateRenderViewForRenderManager(
     RenderViewHost* render_view_host) {
   // Can be NULL during tests.
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
 
   // Now that the RenderView has been created, we need to tell it its size.
   if (rwh_view)
@@ skipping 45 matching lines @@
   encoding_ = content::GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = GetView()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }