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

chrome/browser/automation/automation_provider_observers.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/automation/automation_provider_observers.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 71 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/process_type.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/rect.h"
 
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
+using content::NavigationController;
 using content::WebContents;
 
 // Holds onto start and stop timestamps for a particular tab
 class InitialLoadObserver::TabTime {
  public:
   explicit TabTime(base::TimeTicks started)
       : load_start_time_(started) {
   }
   void set_stop_time(base::TimeTicks stopped) {
     load_stop_time_ = stopped;
@@ skipping 124 matching lines @@
       automation_->Send(
           new AutomationMsg_InitialNewTabUILoadComplete(*load_time.ptr()));
     }
   } else {
     NOTREACHED();
   }
 }
 
 NavigationControllerRestoredObserver::NavigationControllerRestoredObserver(
     AutomationProvider* automation,
-    content::NavigationController* controller,
+    NavigationController* controller,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       controller_(controller),
       reply_message_(reply_message) {
   if (FinishedRestoring()) {
     SendDone();
   } else {
     registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    content::NotificationService::AllSources());
   }
@@ skipping 19 matching lines @@
 void NavigationControllerRestoredObserver::SendDone() {
   if (!automation_)
     return;
 
   AutomationMsg_WaitForTabToBeRestored::WriteReplyParams(reply_message_.get(),
                                                          true);
   automation_->Send(reply_message_.release());
 }
 
 NavigationNotificationObserver::NavigationNotificationObserver(
-    content::NavigationController* controller,
+    NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message,
     int number_of_navigations,
     bool include_current_navigation,
     bool use_json_interface)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       controller_(controller),
       navigations_remaining_(number_of_navigations),
       navigation_started_(false),
       use_json_interface_(use_json_interface) {
   if (number_of_navigations == 0) {
     ConditionMet(AUTOMATION_MSG_NAVIGATION_SUCCESS);
     return;
   }
   DCHECK_LT(0, navigations_remaining_);
-  content::Source<content::NavigationController> source(controller_);
+  content::Source<NavigationController> source(controller_);
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED, source);
   registrar_.Add(this, content::NOTIFICATION_LOAD_START, source);
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
   registrar_.Add(this, chrome::NOTIFICATION_AUTH_NEEDED, source);
   registrar_.Add(this, chrome::NOTIFICATION_AUTH_SUPPLIED, source);
   registrar_.Add(this, chrome::NOTIFICATION_AUTH_CANCELLED, source);
   registrar_.Add(this, chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
                  content::NotificationService::AllSources());
 
   if (include_current_navigation && controller->GetWebContents()->IsLoading())
@@ skipping 84 matching lines @@
 
 void TabStripNotificationObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == notification_) {
     if (type == content::NOTIFICATION_TAB_PARENTED) {
       ObserveTab(&(content::Source<TabContentsWrapper>(source).ptr()->
                      tab_contents()->GetController()));
     } else {
-      ObserveTab(content::Source<content::NavigationController>(source).ptr());
+      ObserveTab(content::Source<NavigationController>(source).ptr());
     }
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 TabAppendedNotificationObserver::TabAppendedNotificationObserver(
     Browser* parent, AutomationProvider* automation,
     IPC::Message* reply_message)
     : TabStripNotificationObserver(content::NOTIFICATION_TAB_PARENTED,
                                    automation),
       parent_(parent),
       reply_message_(reply_message) {
 }
 
 TabAppendedNotificationObserver::~TabAppendedNotificationObserver() {}
 
 void TabAppendedNotificationObserver::ObserveTab(
-    content::NavigationController* controller) {
+    NavigationController* controller) {
   if (!automation_)
     return;
 
   if (automation_->GetIndexForNavigationController(controller, parent_) ==
       TabStripModel::kNoTab) {
     // This tab notification doesn't belong to the parent_.
     return;
   }
 
   new NavigationNotificationObserver(controller, automation_,
                                      reply_message_.release(),
                                      1, false, false);
 }
 
 TabClosedNotificationObserver::TabClosedNotificationObserver(
     AutomationProvider* automation, bool wait_until_closed,
     IPC::Message* reply_message)
     : TabStripNotificationObserver(wait_until_closed ?
           content::NOTIFICATION_TAB_CLOSED : content::NOTIFICATION_TAB_CLOSING,
           automation),
       reply_message_(reply_message),
       for_browser_command_(false) {
 }
 
 TabClosedNotificationObserver::~TabClosedNotificationObserver() {}
 
 void TabClosedNotificationObserver::ObserveTab(
-    content::NavigationController* controller) {
+    NavigationController* controller) {
   if (!automation_)
     return;
 
   if (for_browser_command_) {
     AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                          true);
   } else {
     AutomationMsg_CloseTab::WriteReplyParams(reply_message_.get(), true);
   }
   automation_->Send(reply_message_.release());
@@ skipping 421 matching lines @@
     return;
   }
 
   if (type == chrome::NOTIFICATION_BROWSER_OPENED) {
     // Store the new browser ID and continue waiting for a new tab within it
     // to stop loading.
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         content::Source<Browser>(source).ptr());
   } else if (type == content::NOTIFICATION_LOAD_STOP) {
     // Only send the result if the loaded tab is in the new window.
-    content::NavigationController* controller =
-      content::Source<content::NavigationController>(source).ptr();
+    NavigationController* controller =
+        content::Source<NavigationController>(source).ptr();
     TabContentsWrapper* tab = TabContentsWrapper::GetCurrentWrapperForContents(
         controller->GetWebContents());
     int window_id = tab ? tab->restore_tab_helper()->window_id().id() : -1;
     if (window_id == new_window_id_) {
       if (for_browser_command_) {
         AutomationMsg_WindowExecuteCommand::WriteReplyParams(
             reply_message_.get(), true);
       }
       automation_->Send(reply_message_.release());
       delete this;
@@ skipping 993 matching lines @@
 AutomationProviderBrowsingDataObserver::
     ~AutomationProviderBrowsingDataObserver() {}
 
 void AutomationProviderBrowsingDataObserver::OnBrowsingDataRemoverDone() {
   if (provider_)
     AutomationJSONReply(provider_, reply_message_.release()).SendSuccess(NULL);
   delete this;
 }
 
 OmniboxAcceptNotificationObserver::OmniboxAcceptNotificationObserver(
-    content::NavigationController* controller,
+    NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message)
     : automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       controller_(controller) {
-  content::Source<content::NavigationController> source(controller_);
+  content::Source<NavigationController> source(controller_);
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
   // Pages requiring auth don't send LOAD_STOP.
   registrar_.Add(this, chrome::NOTIFICATION_AUTH_NEEDED, source);
 }
 
 OmniboxAcceptNotificationObserver::~OmniboxAcceptNotificationObserver() {
 }
 
 void OmniboxAcceptNotificationObserver::Observe(
     int type,
@@ skipping 271 matching lines @@
     dict->SetBoolean("is_pinned", top_sites_->IsURLPinned(visited.url));
     list_value->Append(dict);
   }
   ntp_info_->Set("most_visited", list_value);
   AutomationJSONReply(automation_,
                       reply_message_.release()).SendSuccess(ntp_info_.get());
   delete this;
 }
 
 AppLaunchObserver::AppLaunchObserver(
-    content::NavigationController* controller,
+    NavigationController* controller,
     AutomationProvider* automation,
     IPC::Message* reply_message,
     extension_misc::LaunchContainer launch_container)
     : controller_(controller),
       automation_(automation->AsWeakPtr()),
       reply_message_(reply_message),
       launch_container_(launch_container),
       new_window_id_(extension_misc::kUnknownWindowId) {
   if (launch_container_ == extension_misc::LAUNCH_TAB) {
     // Need to wait for the currently-active tab to reload.
-    content::Source<content::NavigationController> source(controller_);
+    content::Source<NavigationController> source(controller_);
     registrar_.Add(this, content::NOTIFICATION_LOAD_STOP, source);
   } else {
     // Need to wait for a new tab in a new window to load.
     registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }
 
 AppLaunchObserver::~AppLaunchObserver() {}
 
 void AppLaunchObserver::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_LOAD_STOP) {
     if (launch_container_ == extension_misc::LAUNCH_TAB) {
       // The app has been launched in the new tab.
       if (automation_) {
         AutomationJSONReply(automation_,
                             reply_message_.release()).SendSuccess(NULL);
       }
       delete this;
       return;
     } else {
       // The app has launched only if the loaded tab is in the new window.
-      content::NavigationController* controller =
-          content::Source<content::NavigationController>(source).ptr();
+      NavigationController* controller =
+          content::Source<NavigationController>(source).ptr();
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               controller->GetWebContents());
       int window_id = tab ? tab->restore_tab_helper()->window_id().id() : -1;
       if (window_id == new_window_id_) {
         if (automation_) {
           AutomationJSONReply(automation_,
                               reply_message_.release()).SendSuccess(NULL);
         }
         delete this;
@@ skipping 492 matching lines @@
   // Use TAB_PARENTED to detect the new tab.
   registrar_.Add(this,
                  content::NOTIFICATION_TAB_PARENTED,
                  content::NotificationService::AllSources());
 }
 
 void NewTabObserver::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   DCHECK_EQ(content::NOTIFICATION_TAB_PARENTED, type);
-  content::NavigationController* controller =
+  NavigationController* controller =
       &(content::Source<TabContentsWrapper>(source).ptr()->
           tab_contents()->GetController());
   if (automation_) {
     // TODO(phajdan.jr): Clean up this hack. We write the correct return type
     // here, but don't send the message. NavigationNotificationObserver
     // will wait properly for the load to finish, and send the message,
     // but it will also append its own return value at the end of the reply.
     AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message_.get(),
                                                          true);
     new NavigationNotificationObserver(controller, automation_,
@@ skipping 200 matching lines @@
           reply_message_.release()).SendError("Profile could not be created.");
       return;
     }
   } else if (type == chrome::NOTIFICATION_BROWSER_OPENED) {
     // Store the new browser ID and continue waiting for a new tab within it
     // to stop loading.
     new_window_id_ = ExtensionTabUtil::GetWindowId(
         content::Source<Browser>(source).ptr());
   } else if (type == content::NOTIFICATION_LOAD_STOP) {
     // Only send the result if the loaded tab is in the new window.
-    content::NavigationController* controller =
-        content::Source<content::NavigationController>(source).ptr();
+    NavigationController* controller =
+        content::Source<NavigationController>(source).ptr();
     TabContentsWrapper* tab = TabContentsWrapper::GetCurrentWrapperForContents(
         controller->GetWebContents());
     int window_id = tab ? tab->restore_tab_helper()->window_id().id() : -1;
     if (window_id == new_window_id_) {
       if (automation_) {
         AutomationJSONReply(automation_, reply_message_.release())
             .SendSuccess(NULL);
       }
       delete this;
     }
@@ skipping 112 matching lines @@
   }
 
   ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
   if (host->extension_id() == extension_id_ &&
       host->extension_host_type() == chrome::VIEW_TYPE_EXTENSION_POPUP) {
     AutomationJSONReply(automation_, reply_message_.release())
         .SendSuccess(NULL);
     delete this;
   }
 }