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

chrome/browser/sessions/session_restore.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/sessions/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <vector>
@@ skipping 24 matching lines @@
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "net/base/network_change_notifier.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/boot_times_loader.h"
 #endif
 
+using content::NavigationController;
 using content::WebContents;
 
 // Are we in the process of restoring?
 static bool restoring = false;
 
 namespace {
 
 // TabLoader ------------------------------------------------------------------
 
 // Initial delay (see class decription for details).
 static const int kInitialDelayTimerMS = 100;
 
 // TabLoader is responsible for loading tabs after session restore creates
 // tabs. New tabs are loaded after the current tab finishes loading, or a delay
 // is reached (initially kInitialDelayTimerMS). If the delay is reached before
 // a tab finishes loading a new tab is loaded and the time of the delay
 // doubled. When all tabs are loading TabLoader deletes itself.
 //
 // This is not part of SessionRestoreImpl so that synchronous destruction
 // of SessionRestoreImpl doesn't have timing problems.
 class TabLoader : public content::NotificationObserver,
                   public net::NetworkChangeNotifier::OnlineStateObserver {
  public:
   explicit TabLoader(base::TimeTicks restore_started);
   virtual ~TabLoader();
 
   // Schedules a tab for loading.
-  void ScheduleLoad(content::NavigationController* controller);
+  void ScheduleLoad(NavigationController* controller);
 
   // Notifies the loader that a tab has been scheduled for loading through
   // some other mechanism.
-  void TabIsLoading(content::NavigationController* controller);
+  void TabIsLoading(NavigationController* controller);
 
   // Invokes |LoadNextTab| to load a tab.
   //
   // This must be invoked once to start loading.
   void StartLoading();
 
  private:
-  typedef std::set<content::NavigationController*> TabsLoading;
-  typedef std::list<content::NavigationController*> TabsToLoad;
+  typedef std::set<NavigationController*> TabsLoading;
+  typedef std::list<NavigationController*> TabsToLoad;
   typedef std::set<RenderWidgetHost*> RenderWidgetHostSet;
 
   // Loads the next tab. If there are no more tabs to load this deletes itself,
   // otherwise |force_load_timer_| is restarted.
   void LoadNextTab();
 
   // NotificationObserver method. Removes the specified tab and loads the next
   // tab.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // net::NetworkChangeNotifier::OnlineStateObserver overrides.
   virtual void OnOnlineStateChanged(bool online) OVERRIDE;
 
   // Removes the listeners from the specified tab and removes the tab from
   // the set of tabs to load and list of tabs we're waiting to get a load
   // from.
-  void RemoveTab(content::NavigationController* tab);
+  void RemoveTab(NavigationController* tab);
 
   // Invoked from |force_load_timer_|. Doubles |force_load_delay_| and invokes
   // |LoadNextTab| to load the next tab
   void ForceLoadTimerFired();
 
   // Returns the RenderWidgetHost associated with a tab if there is one,
   // NULL otherwise.
-  static RenderWidgetHost* GetRenderWidgetHost(
-      content::NavigationController* tab);
+  static RenderWidgetHost* GetRenderWidgetHost(NavigationController* tab);
 
   // Register for necessary notificaitons on a tab navigation controller.
-  void RegisterForNotifications(content::NavigationController* controller);
+  void RegisterForNotifications(NavigationController* controller);
 
   // Called when a tab goes away or a load completes.
-  void HandleTabClosedOrLoaded(content::NavigationController* controller);
+  void HandleTabClosedOrLoaded(NavigationController* controller);
 
   content::NotificationRegistrar registrar_;
 
   // Current delay before a new tab is loaded. See class description for
   // details.
   int64 force_load_delay_;
 
   // Has Load been invoked?
   bool loading_;
 
@@ skipping 31 matching lines @@
       tab_count_(0),
       restore_started_(restore_started) {
 }
 
 TabLoader::~TabLoader() {
   DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
           tabs_loading_.empty() && tabs_to_load_.empty());
   net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
 }
 
-void TabLoader::ScheduleLoad(content::NavigationController* controller) {
+void TabLoader::ScheduleLoad(NavigationController* controller) {
   DCHECK(controller);
   DCHECK(find(tabs_to_load_.begin(), tabs_to_load_.end(), controller) ==
          tabs_to_load_.end());
   tabs_to_load_.push_back(controller);
   RegisterForNotifications(controller);
 }
 
-void TabLoader::TabIsLoading(content::NavigationController* controller) {
+void TabLoader::TabIsLoading(NavigationController* controller) {
   DCHECK(controller);
   DCHECK(find(tabs_loading_.begin(), tabs_loading_.end(), controller) ==
          tabs_loading_.end());
   tabs_loading_.insert(controller);
   RenderWidgetHost* render_widget_host = GetRenderWidgetHost(controller);
   DCHECK(render_widget_host);
   render_widget_hosts_loading_.insert(render_widget_host);
   RegisterForNotifications(controller);
 }
 
 void TabLoader::StartLoading() {
   registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                  content::NotificationService::AllSources());
 #if defined(OS_CHROMEOS)
   if (!net::NetworkChangeNotifier::IsOffline()) {
     loading_ = true;
     LoadNextTab();
   } else {
     net::NetworkChangeNotifier::AddOnlineStateObserver(this);
   }
 #else
   loading_ = true;
   LoadNextTab();
 #endif
 }
 
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
-    content::NavigationController* tab = tabs_to_load_.front();
+    NavigationController* tab = tabs_to_load_.front();
     DCHECK(tab);
     tabs_loading_.insert(tab);
     tabs_to_load_.pop_front();
     tab->LoadIfNecessary();
     if (tab->GetWebContents()) {
       int tab_index;
       Browser* browser = Browser::GetBrowserForController(tab, &tab_index);
       if (browser && browser->active_index() != tab_index) {
         // By default tabs are marked as visible. As only the active tab is
         // visible we need to explicitly tell non-active tabs they are hidden.
@@ skipping 18 matching lines @@
 }
 
 void TabLoader::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_LOAD_START: {
       // Add this render_widget_host to the set of those we're waiting for
       // paints on. We want to only record stats for paints that occur after
       // a load has finished.
-      content::NavigationController* tab =
-          content::Source<content::NavigationController>(source).ptr();
+      NavigationController* tab =
+          content::Source<NavigationController>(source).ptr();
       RenderWidgetHost* render_widget_host = GetRenderWidgetHost(tab);
       DCHECK(render_widget_host);
       render_widget_hosts_loading_.insert(render_widget_host);
       break;
     }
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
       WebContents* web_contents = content::Source<WebContents>(source).ptr();
       if (!got_first_paint_) {
         RenderWidgetHost* render_widget_host =
             GetRenderWidgetHost(&web_contents->GetController());
         render_widget_hosts_loading_.erase(render_widget_host);
       }
       HandleTabClosedOrLoaded(&web_contents->GetController());
       break;
     }
     case content::NOTIFICATION_LOAD_STOP: {
-      content::NavigationController* tab =
-          content::Source<content::NavigationController>(source).ptr();
+      NavigationController* tab =
+          content::Source<NavigationController>(source).ptr();
       render_widget_hosts_to_paint_.insert(GetRenderWidgetHost(tab));
       HandleTabClosedOrLoaded(tab);
       break;
     }
     case content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT: {
       if (!got_first_paint_) {
         RenderWidgetHost* render_widget_host =
             content::Source<RenderWidgetHost>(source).ptr();
         if (render_widget_hosts_to_paint_.find(render_widget_host) !=
             render_widget_hosts_to_paint_.end()) {
@@ skipping 44 matching lines @@
   if (online) {
     if (!loading_) {
       loading_ = true;
       LoadNextTab();
     }
   } else {
     loading_ = false;
   }
 }
 
-void TabLoader::RemoveTab(content::NavigationController* tab) {
+void TabLoader::RemoveTab(NavigationController* tab) {
   registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                     content::Source<WebContents>(tab->GetWebContents()));
   registrar_.Remove(this, content::NOTIFICATION_LOAD_STOP,
-                    content::Source<content::NavigationController>(tab));
+                    content::Source<NavigationController>(tab));
   registrar_.Remove(this, content::NOTIFICATION_LOAD_START,
-                    content::Source<content::NavigationController>(tab));
+                    content::Source<NavigationController>(tab));
 
   TabsLoading::iterator i = tabs_loading_.find(tab);
   if (i != tabs_loading_.end())
     tabs_loading_.erase(i);
 
   TabsToLoad::iterator j =
       find(tabs_to_load_.begin(), tabs_to_load_.end(), tab);
   if (j != tabs_to_load_.end())
     tabs_to_load_.erase(j);
 }
 
 void TabLoader::ForceLoadTimerFired() {
   force_load_delay_ *= 2;
   LoadNextTab();
 }
 
-RenderWidgetHost* TabLoader::GetRenderWidgetHost(
-    content::NavigationController* tab) {
+RenderWidgetHost* TabLoader::GetRenderWidgetHost(NavigationController* tab) {
   WebContents* web_contents = tab->GetWebContents();
   if (web_contents) {
     RenderWidgetHostView* render_widget_host_view =
         web_contents->GetRenderWidgetHostView();
     if (render_widget_host_view)
       return render_widget_host_view->GetRenderWidgetHost();
   }
   return NULL;
 }
 
-void TabLoader::RegisterForNotifications(
-    content::NavigationController* controller) {
+void TabLoader::RegisterForNotifications(NavigationController* controller) {
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::Source<WebContents>(controller->GetWebContents()));
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
-                 content::Source<content::NavigationController>(controller));
+                 content::Source<NavigationController>(controller));
   registrar_.Add(this, content::NOTIFICATION_LOAD_START,
-                 content::Source<content::NavigationController>(controller));
+                 content::Source<NavigationController>(controller));
   ++tab_count_;
 }
 
-void TabLoader::HandleTabClosedOrLoaded(content::NavigationController* tab) {
+void TabLoader::HandleTabClosedOrLoaded(NavigationController* tab) {
   RemoveTab(tab);
   if (loading_)
     LoadNextTab();
   if (tabs_loading_.empty() && tabs_to_load_.empty()) {
     base::TimeDelta time_to_load =
         base::TimeTicks::Now() - restore_started_;
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "SessionRestore.AllTabsLoaded",
         time_to_load,
         base::TimeDelta::FromMilliseconds(10),
@@ skipping 514 matching lines @@
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
       static_cast<Browser*>(NULL), true, false, true, gurls);
   restorer.RestoreForeignTab(tab);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }