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

chrome/browser/ui/browser.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 "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 189 matching lines @@
 
 #if !defined(OS_CHROMEOS) || defined(USE_AURA)
 #include "chrome/browser/download/download_shelf.h"
 #endif
 
 #if defined(FILE_MANAGER_EXTENSION)
 #include "chrome/browser/extensions/file_manager_util.h"
 #endif
 
 using base::TimeDelta;
+using content::NavigationEntry;
 using content::OpenURLParams;
 using content::PluginService;
 using content::Referrer;
 using content::SSLStatus;
 using content::UserMetricsAction;
 using content::WebContents;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
@@ skipping 25 matching lines @@
 
 // The URL for the privacy dashboard.
 const char kPrivacyDashboardUrl[] = "https://www.google.com/dashboard";
 
 // How long we wait before updating the browser chrome while loading a page.
 const int kUIUpdateCoalescingTimeMS = 200;
 
 const char kHashMark[] = "#";
 
 // Returns |true| if entry has an internal chrome:// URL, |false| otherwise.
-bool HasInternalURL(const content::NavigationEntry* entry) {
+bool HasInternalURL(const NavigationEntry* entry) {
   if (!entry)
     return false;
 
   // Check the |virtual_url()| first. This catches regular chrome:// URLs
   // including URLs that were rewritten (such as chrome://bookmarks).
   if (entry->GetVirtualURL().SchemeIs(chrome::kChromeUIScheme))
     return true;
 
   // If the |virtual_url()| isn't a chrome:// URL, check if it's actually
   // view-source: of a chrome:// URL.
@@ skipping 1033 matching lines @@
     SessionStorageNamespace* session_storage_namespace) {
   GURL restore_url = navigations.at(selected_navigation).virtual_url();
   TabContentsWrapper* wrapper = TabContentsFactory(
       profile(),
       tab_util::GetSiteInstanceForNewTab(NULL, profile_, restore_url),
       MSG_ROUTING_NONE,
       GetSelectedTabContents(),
       session_storage_namespace);
   TabContents* new_tab = wrapper->tab_contents();
   wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
-  std::vector<content::NavigationEntry*> entries;
+  std::vector<NavigationEntry*> entries;
   TabNavigation::CreateNavigationEntriesFromTabNavigations(
       profile_, navigations, &entries);
   new_tab->GetController().Restore(
       selected_navigation, from_last_session, &entries);
   DCHECK_EQ(0u, entries.size());
 
   int add_types = select ? TabStripModel::ADD_ACTIVE :
       TabStripModel::ADD_NONE;
   if (pin) {
     tab_index = std::min(tab_index, tabstrip_model()->IndexOfFirstNonMiniTab());
@@ skipping 29 matching lines @@
     SessionStorageNamespace* session_storage_namespace) {
   GURL restore_url = navigations.at(selected_navigation).virtual_url();
   TabContentsWrapper* wrapper = TabContentsFactory(
       profile(),
       tab_util::GetSiteInstanceForNewTab(NULL, profile_, restore_url),
       MSG_ROUTING_NONE,
       GetSelectedTabContents(),
       session_storage_namespace);
   wrapper->extension_tab_helper()->SetExtensionAppById(extension_app_id);
   TabContents* replacement = wrapper->tab_contents();
-  std::vector<content::NavigationEntry*> entries;
+  std::vector<NavigationEntry*> entries;
   TabNavigation::CreateNavigationEntriesFromTabNavigations(
       profile_, navigations, &entries);
   replacement->GetController().Restore(
       selected_navigation, from_last_session, &entries);
   DCHECK_EQ(0u, entries.size());
 
   tab_handler_->GetTabStripModel()->ReplaceNavigationControllerAt(
       tab_handler_->GetTabStripModel()->active_index(),
       wrapper);
 }
@@ skipping 171 matching lines @@
 void Browser::ReloadIgnoringCache(WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("ReloadIgnoringCache"));
   ReloadInternal(disposition, true);
 }
 
 void Browser::ReloadInternal(WindowOpenDisposition disposition,
                              bool ignore_cache) {
   // If we are showing an interstitial, treat this as an OpenURL.
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab && current_tab->ShowingInterstitialPage()) {
-    content::NavigationEntry* entry =
-        current_tab->GetController().GetActiveEntry();
+    NavigationEntry* entry = current_tab->GetController().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
     OpenURL(OpenURLParams(
         entry->GetURL(), Referrer(), disposition,
         content::PAGE_TRANSITION_RELOAD, false));
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
   TabContents* tab = GetOrCloneTabForDisposition(disposition);
   if (!tab->FocusLocationBarByDefault())
@@ skipping 498 matching lines @@
 }
 
 void Browser::OpenCreateShortcutsDialog() {
   content::RecordAction(UserMetricsAction("CreateShortcut"));
 #if !defined(OS_MACOSX)
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   DCHECK(current_tab &&
       web_app::IsValidUrl(current_tab->tab_contents()->GetURL())) <<
           "Menu item should be disabled.";
 
-  content::NavigationEntry* entry =
+  NavigationEntry* entry =
       current_tab->tab_contents()->GetController().GetLastCommittedEntry();
   if (!entry)
     return;
 
   // RVH's GetApplicationInfo should not be called before it returns.
   DCHECK(pending_web_app_action_ == NONE);
   pending_web_app_action_ = CREATE_SHORTCUT;
 
   // Start fetching web app info for CreateApplicationShortcut dialog and show
   // the dialog when the data is available in OnDidGetApplicationInfo.
@@ skipping 94 matching lines @@
 }
 
 void Browser::ShowAboutConflictsTab() {
   content::RecordAction(UserMetricsAction("AboutConflicts"));
   ShowSingletonTab(GURL(chrome::kChromeUIConflictsURL));
 }
 
 void Browser::ShowBrokenPageTab(TabContents* contents) {
   content::RecordAction(UserMetricsAction("ReportBug"));
   string16 page_title = contents->GetTitle();
-  content::NavigationEntry* entry = contents->GetController().GetActiveEntry();
+  NavigationEntry* entry = contents->GetController().GetActiveEntry();
   if (!entry)
     return;
   std::string page_url = entry->GetURL().spec();
   std::vector<std::string> subst;
   subst.push_back(UTF16ToASCII(page_title));
   subst.push_back(page_url);
   std::string report_page_url =
       ReplaceStringPlaceholders(kBrokenPageUrl, subst, NULL);
   ShowSingletonTab(GURL(report_page_url));
 }
@@ skipping 1341 matching lines @@
     if (GetStatusBubble()) {
       GetStatusBubble()->SetStatus(
           GetSelectedTabContentsWrapper()->core_tab_helper()->GetStatusText());
     }
 
     if (!is_loading && pending_web_app_action_ == UPDATE_SHORTCUT) {
       // Schedule a shortcut update when web application info is available if
       // last committed entry is not NULL. Last committed entry could be NULL
       // when an interstitial page is injected (e.g. bad https certificate,
       // malware site etc). When this happens, we abort the shortcut update.
-      content::NavigationEntry* entry =
-          source->GetController().GetLastCommittedEntry();
+      NavigationEntry* entry = source->GetController().GetLastCommittedEntry();
       if (entry) {
         TabContentsWrapper::GetCurrentWrapperForContents(source)->
             extension_tab_helper()->GetApplicationInfo(entry->GetPageID());
       } else {
         pending_web_app_action_ = NONE;
       }
     }
   }
 }
 
@@ skipping 424 matching lines @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CoreTabHelperDelegate implementation:
 
 void Browser::OnDidGetApplicationInfo(TabContentsWrapper* source,
                                       int32 page_id) {
   if (GetSelectedTabContentsWrapper() != source)
     return;
 
-  content::NavigationEntry* entry =
+  NavigationEntry* entry =
       source->tab_contents()->GetController().GetLastCommittedEntry();
   if (!entry || (entry->GetPageID() != page_id))
     return;
 
   switch (pending_web_app_action_) {
     case CREATE_SHORTCUT: {
       window()->ShowCreateWebAppShortcutsDialog(source);
       break;
     }
     case UPDATE_SHORTCUT: {
@@ skipping 1199 matching lines @@
   if (is_type_tabbed() && InstantController::IsEnabled(profile()) &&
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(profile_, this));
     instant_unload_handler_.reset(new InstantUnloadHandler(this));
   }
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents) {
   DCHECK(contents);
 
-  content::NavigationEntry* active_entry =
+  NavigationEntry* active_entry =
       contents->tab_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   ViewSource(contents, active_entry->GetURL(), active_entry->GetContentState());
 }
 
 void Browser::ViewSource(TabContentsWrapper* contents,
                          const GURL& url,
                          const std::string& content_state) {
   content::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
   TabContentsWrapper* view_source_contents = contents->Clone();
   view_source_contents->tab_contents()->GetController().PruneAllButActive();
-  content::NavigationEntry* active_entry =
+  NavigationEntry* active_entry =
       view_source_contents->tab_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   GURL view_source_url = GURL(chrome::kViewSourceScheme + std::string(":") +
       url.spec());
   active_entry->SetVirtualURL(view_source_url);
 
   // Do not restore scroller position.
   active_entry->SetContentState(
@@ skipping 34 matching lines @@
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
 }
 
 int Browser::GetContentRestrictionsForSelectedTab() {
   int content_restrictions = 0;
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab) {
     content_restrictions = current_tab->GetContentRestrictions();
-    content::NavigationEntry* active_entry =
+    NavigationEntry* active_entry =
         current_tab->GetController().GetActiveEntry();
     // See comment in UpdateCommandsForTabState about why we call url().
     if (!SavePackage::IsSavableURL(
             active_entry ? active_entry->GetURL() : GURL())
         || current_tab->ShowingInterstitialPage())
       content_restrictions |= content::CONTENT_RESTRICTION_SAVE;
     if (current_tab->ShowingInterstitialPage())
       content_restrictions |= content::CONTENT_RESTRICTION_PRINT;
   }
   return content_restrictions;
@@ skipping 84 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }