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

chrome/browser/automation/automation_provider.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.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 86 matching lines @@
 #endif  // defined(OS_WIN)
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif  // defined(OS_CHROMEOS)
 
 using WebKit::WebFindOptions;
 using base::Time;
 using content::BrowserThread;
 using content::DownloadItem;
+using content::NavigationController;
 using content::WebContents;
 
 namespace {
 
 void PopulateProxyConfig(const DictionaryValue& dict, net::ProxyConfig* pc) {
   DCHECK(pc);
   bool no_proxy = false;
   if (dict.GetBoolean(automation::kJSONProxyNoProxy, &no_proxy)) {
     // Make no changes to the ProxyConfig.
     return;
@@ skipping 167 matching lines @@
 }
 
 void AutomationProvider::OnLoginWebuiReady() {
   login_webui_ready_ = true;
   VLOG(2) << "OnLoginWebuiReady";
   if (is_connected_ && initial_tab_loads_complete_ &&
       network_library_initialized_)
     Send(new AutomationMsg_InitialLoadsComplete());
 }
 
-void AutomationProvider::AddLoginHandler(content::NavigationController* tab,
+void AutomationProvider::AddLoginHandler(NavigationController* tab,
                                          LoginHandler* handler) {
   login_handler_map_[tab] = handler;
 }
 
-void AutomationProvider::RemoveLoginHandler(content::NavigationController* tab) {
+void AutomationProvider::RemoveLoginHandler(NavigationController* tab) {
   DCHECK(login_handler_map_[tab]);
   login_handler_map_.erase(tab);
 }
 
 int AutomationProvider::GetIndexForNavigationController(
-    const content::NavigationController* controller,
-    const Browser* parent) const {
+    const NavigationController* controller, const Browser* parent) const {
   DCHECK(parent);
   return parent->GetIndexOfController(controller);
 }
 
 int AutomationProvider::AddExtension(const Extension* extension) {
   DCHECK(extension);
   return extension_tracker_->Add(extension);
 }
 
 // TODO(phajdan.jr): move to TestingAutomationProvider.
@@ skipping 203 matching lines @@
   VLOG(1) << "AutomationProxy went away, shutting down app.";
   g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 bool AutomationProvider::Send(IPC::Message* msg) {
   DCHECK(channel_.get());
   return channel_->Send(msg);
 }
 
 Browser* AutomationProvider::FindAndActivateTab(
-    content::NavigationController* controller) {
+    NavigationController* controller) {
   int tab_index;
   Browser* browser = Browser::GetBrowserForController(controller, &tab_index);
   if (browser)
     browser->ActivateTabAt(tab_index, true);
 
   return browser;
 }
 
 void AutomationProvider::HandleFindRequest(
     int handle,
     const AutomationMsg_Find_Params& params,
     IPC::Message* reply_message) {
   if (!tab_tracker_->ContainsHandle(handle)) {
     AutomationMsg_Find::WriteReplyParams(reply_message, -1, -1);
     Send(reply_message);
     return;
   }
 
-  content::NavigationController* nav = tab_tracker_->GetResource(handle);
+  NavigationController* nav = tab_tracker_->GetResource(handle);
   WebContents* web_contents = nav->GetWebContents();
 
   SendFindRequest(web_contents,
                   false,
                   params.search_string,
                   params.forward,
                   params.match_case,
                   params.find_next,
                   reply_message);
 }
@@ skipping 34 matching lines @@
       profile_->GetRequestContext();
   DCHECK(context_getter);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(SetProxyConfigCallback, make_scoped_refptr(context_getter),
                  new_proxy_config));
 }
 
 WebContents* AutomationProvider::GetWebContentsForHandle(
-    int handle, content::NavigationController** tab) {
+    int handle, NavigationController** tab) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* nav_controller =
-        tab_tracker_->GetResource(handle);
+    NavigationController* nav_controller = tab_tracker_->GetResource(handle);
     if (tab)
       *tab = nav_controller;
     return nav_controller->GetWebContents();
   }
   return NULL;
 }
 
 // Gets the current used encoding name of the page in the specified tab.
 void AutomationProvider::OverrideEncoding(int tab_handle,
                                           const std::string& encoding_name,
                                           bool* success) {
   *success = false;
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* nav = tab_tracker_->GetResource(tab_handle);
+    NavigationController* nav = tab_tracker_->GetResource(tab_handle);
     if (!nav)
       return;
     Browser* browser = FindAndActivateTab(nav);
 
     // If the browser has UI, simulate what a user would do.
     // Activate the tab and then click the encoding menu.
     if (browser &&
         browser->command_updater()->IsCommandEnabled(IDC_ENCODING_MENU)) {
       int selected_encoding_id =
           CharacterEncoding::GetCommandIdByCanonicalEncodingName(encoding_name);
@@ skipping 51 matching lines @@
   if (!view) {
     NOTREACHED();
     return;
   }
 
   view->Paste();
 }
 
 void AutomationProvider::ReloadAsync(int tab_handle) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     if (!tab) {
       NOTREACHED();
       return;
     }
 
     const bool check_for_repost = true;
     tab->Reload(check_for_repost);
   }
 }
 
@@ skipping 15 matching lines @@
       static_cast<AutomationPageFontSize>(font_size);
 
   if (automation_font_size < SMALLEST_FONT ||
       automation_font_size > LARGEST_FONT) {
       DLOG(ERROR) << "Invalid font size specified : "
                   << font_size;
       return;
   }
 
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     DCHECK(tab != NULL);
     if (tab && tab->GetWebContents()) {
       DCHECK(tab->GetWebContents()->GetBrowserContext() != NULL);
       Profile* profile = Profile::FromBrowserContext(
           tab->GetWebContents()->GetBrowserContext());
       profile->GetPrefs()->SetInteger(
           prefs::kWebKitGlobalDefaultFontSize, font_size);
     }
   }
 }
@@ skipping 50 matching lines @@
     *success = false;
   } else {
     *chunk = tracing_data_.trace_output.front();
     tracing_data_.trace_output.pop_front();
     *success = true;
   }
 }
 
 RenderViewHost* AutomationProvider::GetViewForTab(int tab_handle) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     if (!tab) {
       NOTREACHED();
       return NULL;
     }
 
     WebContents* web_contents = tab->GetWebContents();
     if (!web_contents) {
       NOTREACHED();
       return NULL;
     }
@@ skipping 187 matching lines @@
         }
         break;
       default:
         LOG(WARNING) << "Trying to get undefined extension property";
         break;
     }
   }
 }
 
 void AutomationProvider::SaveAsAsync(int tab_handle) {
-  content::NavigationController* tab = NULL;
+  NavigationController* tab = NULL;
   WebContents* web_contents = GetWebContentsForHandle(tab_handle, &tab);
   if (web_contents)
     web_contents->OnSavePage();
 }