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

content/browser/tab_contents/navigation_controller_impl.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_impl.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"  // Temporary
 #include "base/string_util.h"
@@ skipping 15 matching lines @@
 #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::BrowserContext;
 using content::GlobalRequestID;
+using content::NavigationController;
 using content::NavigationEntry;
 using content::NavigationEntryImpl;
 using content::UserMetricsAction;
 using content::WebContents;
 
 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;
   details.from_front = from_front;
   details.count = count;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_NAV_LIST_PRUNED,
-      content::Source<content::NavigationController>(nav_controller),
+      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.
@@ skipping 114 matching lines @@
     session_storage_namespace_ = new SessionStorageNamespace(
         browser_context_->GetWebKitContext());
   }
 }
 
 NavigationControllerImpl::~NavigationControllerImpl() {
   DiscardNonCommittedEntriesInternal();
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSED,
-      content::Source<content::NavigationController>(this),
+      content::Source<NavigationController>(this),
       content::NotificationService::NoDetails());
 }
 
 WebContents* NavigationControllerImpl::GetWebContents() const {
   return tab_contents_;
 }
 
 BrowserContext* NavigationControllerImpl::GetBrowserContext() const {
   return browser_context_;
 }
@@ skipping 45 matching lines @@
     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<content::NavigationController>(this),
+        content::Source<NavigationController>(this),
         content::NotificationService::NoDetails());
 
     pending_reload_ = reload_type;
     tab_contents_->Activate();
     tab_contents_->GetDelegate()->ShowRepostFormWarningDialog(tab_contents_);
   } else {
     DiscardNonCommittedEntriesInternal();
 
     pending_entry_index_ = current_index;
     entries_[pending_entry_index_]->SetTransitionType(
@@ skipping 40 matching lines @@
     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<content::NavigationController>(this),
+      content::Source<NavigationController>(this),
       content::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 637 matching lines @@
 }
 
 bool NavigationControllerImpl::IsURLInPageNavigation(const GURL& url) const {
   NavigationEntry* last_committed = GetLastCommittedEntry();
   if (!last_committed)
     return false;
   return AreURLsInPageNavigation(last_committed->GetURL(), url);
 }
 
 void NavigationControllerImpl::CopyStateFrom(
-    const content::NavigationController& temp) {
+    const NavigationController& temp) {
   const NavigationControllerImpl& source =
       static_cast<const NavigationControllerImpl&>(temp);
   // Verify that we look new.
   DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
 
   if (source.GetEntryCount() == 0)
     return;  // Nothing new to do.
 
   needs_reload_ = true;
   InsertEntriesFrom(source, source.GetEntryCount());
 
   session_storage_namespace_ = source.session_storage_namespace_->Clone();
 
   FinishRestore(source.last_committed_entry_index_, false);
 }
 
 void NavigationControllerImpl::CopyStateFromAndPrune(
-    content::NavigationController* temp) {
+    NavigationController* temp) {
   NavigationControllerImpl* source =
       static_cast<NavigationControllerImpl*>(temp);
   // 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.
   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;
@@ skipping 237 matching lines @@
   // 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.
   tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<content::NavigationController>(this),
+      content::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;
 }
 
@@ skipping 13 matching lines @@
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::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<content::NavigationController>(this),
+      content::Source<NavigationController>(this),
       content::Details<content::EntryChangedDetails>(&det));
 }
 
 void NavigationControllerImpl::FinishRestore(int selected_index,
                                              bool from_last_session) {
   DCHECK(selected_index >= 0 && selected_index < GetEntryCount());
   ConfigureEntriesForRestore(&entries_, from_last_session);
 
   SetMaxRestoredPageID(static_cast<int32>(GetEntryCount()));
 
@@ skipping 42 matching lines @@
   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<NavigationEntryImpl>(
                           new NavigationEntryImpl(*source.entries_[i])));
     }
   }
 }