Get rid of content::NavigationController in cc file and use "using" instead.

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::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::PluginService;
 using content::Referrer;
 using content::SSLStatus;
 using content::UserMetricsAction;
 using content::WebContents;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 952 matching lines @@
 
 int Browser::tab_count() const {
   return tab_handler_->GetTabStripModel()->count();
 }
 
 int Browser::active_index() const {
   return tab_handler_->GetTabStripModel()->active_index();
 }
 
 int Browser::GetIndexOfController(
-    const content::NavigationController* controller) const {
+    const NavigationController* controller) const {
   return tab_handler_->GetTabStripModel()->GetIndexOfController(controller);
 }
 
 TabContentsWrapper* Browser::GetSelectedTabContentsWrapper() const {
   return tabstrip_model()->GetActiveTabContents();
 }
 
 WebContents* Browser::GetSelectedWebContents() const {
   TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
   return wrapper ? wrapper->web_contents() : NULL;
@@ skipping 173 matching lines @@
       tab_handler_->GetTabStripModel()->active_index(),
       wrapper);
 }
 
 bool Browser::CanRestoreTab() {
   return command_updater_.IsCommandEnabled(IDC_RESTORE_TAB);
 }
 
 bool Browser::NavigateToIndexWithDisposition(int index,
                                              WindowOpenDisposition disp) {
-  content::NavigationController& controller =
+  NavigationController& controller =
       GetOrCloneTabForDisposition(disp)->GetController();
   if (index < 0 || index >= controller.GetEntryCount())
     return false;
   controller.GoToIndex(index);
   return true;
 }
 
 browser::NavigateParams Browser::GetSingletonTabNavigateParams(
     const GURL& url) {
   browser::NavigateParams params(
@@ skipping 1127 matching lines @@
     // to proceed closing the page or not, which sends us back to this method
     // with the NeedToFireBeforeUnload bit cleared.
     contents->GetRenderViewHost()->FirePageBeforeUnload(false);
     return true;
   }
   return false;
 }
 
 // static
 Browser* Browser::GetBrowserForController(
-    const content::NavigationController* controller, int* index_result) {
+    const NavigationController* controller, int* index_result) {
   BrowserList::const_iterator it;
   for (it = BrowserList::begin(); it != BrowserList::end(); ++it) {
     int index = (*it)->tab_handler_->GetTabStripModel()->GetIndexOfController(
         controller);
     if (index != TabStripModel::kNoTab) {
       if (index_result)
         *index_result = index;
       return *it;
     }
   }
@@ skipping 561 matching lines @@
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
     contents->tab_contents()->GetController().LoadURL(
         url, referrer, transition, std::string());
   }
 
   return contents;
 }
 
 bool Browser::CanDuplicateContentsAt(int index) {
-  content::NavigationController& nc = GetTabContentsAt(index)->GetController();
+  NavigationController& nc = GetTabContentsAt(index)->GetController();
   return nc.GetWebContents() && nc.GetLastCommittedEntry();
 }
 
 void Browser::DuplicateContentsAt(int index) {
   TabContentsWrapper* contents = GetTabContentsWrapperAt(index);
   CHECK(contents);
   TabContentsWrapper* contents_dupe = contents->Clone();
 
   bool pinned = false;
   if (CanSupportWindowFeature(FEATURE_TABSTRIP)) {
@@ skipping 149 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_DETACHED,
                  content::Source<WebContents>(contents->web_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContentsWrapper* contents,
                            int index) {
   fullscreen_controller_->OnTabClosing(contents->tab_contents());
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSING,
-      content::Source<content::NavigationController>(
+      content::Source<NavigationController>(
           &contents->web_contents()->GetController()),
       content::NotificationService::NoDetails());
 
   // Sever the TabContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
 void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
@@ skipping 815 matching lines @@
 
     case content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED:
       // When the current tab's SSL state changes, we need to update the URL
       // bar to reflect the new state. Note that it's possible for the selected
       // tab contents to be NULL. This is because we listen for all sources
       // (NavigationControllers) for convenience, so the notification could
       // actually be for a different window while we're doing asynchronous
       // closing of this one.
       if (GetSelectedWebContents() &&
           &GetSelectedWebContents()->GetController() ==
-          content::Source<content::NavigationController>(source).ptr())
+          content::Source<NavigationController>(source).ptr())
         UpdateToolbar(false);
       break;
 
     case chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED: {
       // Show the UI if the extension was disabled for escalated permissions.
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile_->IsSameProfile(profile)) {
         ExtensionService* service = profile->GetExtensionService();
         DCHECK(service);
         const Extension* extension =
@@ skipping 466 matching lines @@
   UpdateCommandsForBookmarkBar();
 }
 
 void Browser::UpdateCommandsForTabState() {
   WebContents* current_tab = GetSelectedWebContents();
   TabContentsWrapper* current_tab_wrapper = GetSelectedTabContentsWrapper();
   if (!current_tab || !current_tab_wrapper)  // May be NULL during tab restore.
     return;
 
   // Navigation commands
-  content::NavigationController& nc = current_tab->GetController();
+  NavigationController& nc = current_tab->GetController();
   command_updater_.UpdateCommandEnabled(IDC_BACK, nc.CanGoBack());
   command_updater_.UpdateCommandEnabled(IDC_FORWARD, nc.CanGoForward());
   command_updater_.UpdateCommandEnabled(IDC_RELOAD,
                                         CanReloadContents(current_tab));
   command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE,
                                         CanReloadContents(current_tab));
 
   // Window management commands
   command_updater_.UpdateCommandEnabled(IDC_DUPLICATE_TAB,
       !is_app() && CanDuplicateContentsAt(active_index()));
@@ skipping 780 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }