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

chrome/browser/automation/testing_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/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 137 matching lines @@
 #include "chrome/browser/download/download_shelf.h"
 #endif
 
 using automation::Error;
 using automation::ErrorCode;
 using automation_util::SendErrorIfModalDialogActive;
 using content::BrowserThread;
 using content::ChildProcessHost;
 using content::DownloadItem;
 using content::DownloadManager;
+using content::NavigationController;
 using content::NavigationEntry;
 using content::PluginService;
 using content::OpenURLParams;
 using content::Referrer;
 using content::SSLStatus;
 using content::WebContents;
 
 namespace {
 
 void SendMouseClick(int flags) {
@@ skipping 396 matching lines @@
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     *active_tab_index = browser->active_index();
   }
 }
 
 void TestingAutomationProvider::CloseTab(int tab_handle,
                                          bool wait_until_closed,
                                          IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* controller =
-        tab_tracker_->GetResource(tab_handle);
+    NavigationController* controller = tab_tracker_->GetResource(tab_handle);
     int index;
     Browser* browser = Browser::GetBrowserForController(controller, &index);
     DCHECK(browser);
     new TabClosedNotificationObserver(this, wait_until_closed, reply_message);
     browser->CloseTabContents(controller->GetWebContents());
     return;
   }
 
   AutomationMsg_CloseTab::WriteReplyParams(reply_message, false);
   Send(reply_message);
@@ skipping 21 matching lines @@
                                              int handle, bool* success) {
   WebContents* contents = tab_tracker_->ContainsHandle(handle) ?
       tab_tracker_->GetResource(handle)->GetWebContents() : NULL;
   automation_util::DeleteCookie(url, cookie_name, contents, success);
 }
 
 void TestingAutomationProvider::ShowCollectedCookiesDialog(
     int handle, bool* success) {
   *success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* controller =
-        tab_tracker_->GetResource(handle);
+    NavigationController* controller = tab_tracker_->GetResource(handle);
     WebContents* tab_contents = controller->GetWebContents();
     Browser* browser = Browser::GetBrowserForController(controller, NULL);
     browser->ShowCollectedCookiesDialog(
         TabContentsWrapper::GetCurrentWrapperForContents(tab_contents));
     *success = true;
   }
 }
 
 void TestingAutomationProvider::NavigateToURLBlockUntilNavigationsComplete(
     int handle, const GURL& url, int number_of_navigations,
     IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
 
     // Simulate what a user would do. Activate the tab and then navigate.
     // We could allow navigating in a background tab in future.
     Browser* browser = FindAndActivateTab(tab);
 
     if (browser) {
       new NavigationNotificationObserver(tab, this, reply_message,
                                          number_of_navigations, false, false);
 
       // TODO(darin): avoid conversion to GURL.
@@ skipping 16 matching lines @@
 }
 
 void TestingAutomationProvider::NavigationAsyncWithDisposition(
     int handle,
     const GURL& url,
     WindowOpenDisposition disposition,
     bool* status) {
   *status = false;
 
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
 
     // Simulate what a user would do. Activate the tab and then navigate.
     // We could allow navigating in a background tab in future.
     Browser* browser = FindAndActivateTab(tab);
 
     if (browser) {
       // Don't add any listener unless a callback mechanism is desired.
       // TODO(vibhor): Do this if such a requirement arises in future.
       OpenURLParams params(
           url, Referrer(), disposition, content::PAGE_TRANSITION_TYPED, false);
       browser->OpenURL(params);
       *status = true;
     }
   }
 }
 
 void TestingAutomationProvider::Reload(int handle,
                                        IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = FindAndActivateTab(tab);
     if (browser && browser->command_updater()->IsCommandEnabled(IDC_RELOAD)) {
       new NavigationNotificationObserver(
           tab, this, reply_message, 1, false, false);
       browser->Reload(CURRENT_TAB);
       return;
     }
   }
 
   AutomationMsg_Reload::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::SetAuth(int tab_handle,
                                         const std::wstring& username,
                                         const std::wstring& password,
                                         IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     LoginHandlerMap::iterator iter = login_handler_map_.find(tab);
 
     if (iter != login_handler_map_.end()) {
       // If auth is needed again after this, assume login has failed.  This is
       // not strictly correct, because a navigation can require both proxy and
       // server auth, but it should be OK for now.
       LoginHandler* handler = iter->second;
       new NavigationNotificationObserver(
           tab, this, reply_message, 1, false, false);
       handler->SetAuth(WideToUTF16Hack(username), WideToUTF16Hack(password));
       return;
     }
   }
 
   AutomationMsg_SetAuth::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::CancelAuth(int tab_handle,
                                            IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     LoginHandlerMap::iterator iter = login_handler_map_.find(tab);
 
     if (iter != login_handler_map_.end()) {
       // If auth is needed again after this, something is screwy.
       LoginHandler* handler = iter->second;
       new NavigationNotificationObserver(
           tab, this, reply_message, 1, false, false);
       handler->CancelAuth();
       return;
     }
   }
 
   AutomationMsg_CancelAuth::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::NeedsAuth(int tab_handle, bool* needs_auth) {
   *needs_auth = false;
 
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     LoginHandlerMap::iterator iter = login_handler_map_.find(tab);
 
     if (iter != login_handler_map_.end()) {
       // The LoginHandler will be in our map IFF the tab needs auth.
       *needs_auth = true;
     }
   }
 }
 
 void TestingAutomationProvider::GetRedirectsFrom(int tab_handle,
                                                  const GURL& source_url,
                                                  IPC::Message* reply_message) {
   if (redirect_query_) {
     LOG(ERROR) << "Can only handle one redirect query at once.";
   } else if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
     HistoryService* history_service =
         profile->GetHistoryService(Profile::EXPLICIT_ACCESS);
 
     DCHECK(history_service) << "Tab " << tab_handle << "'s profile " <<
                                "has no history service";
     if (history_service) {
       DCHECK(!reply_message_);
       reply_message_ = reply_message;
       // Schedule a history query for redirects. The response will be sent
@@ skipping 499 matching lines @@
     if (rph)
       *process_id = base::GetProcId(rph->GetHandle());
   }
 }
 
 void TestingAutomationProvider::GetTabTitle(int handle,
                                             int* title_string_size,
                                             std::wstring* title) {
   *title_string_size = -1;  // -1 is the error code
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     NavigationEntry* entry = tab->GetActiveEntry();
     if (entry != NULL) {
       *title = UTF16ToWideHack(entry->GetTitleForDisplay(""));
     } else {
       *title = std::wstring();
     }
     *title_string_size = static_cast<int>(title->size());
   }
 }
 
 void TestingAutomationProvider::GetTabIndex(int handle, int* tabstrip_index) {
   *tabstrip_index = -1;  // -1 is the error code
 
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = Browser::GetBrowserForController(tab, NULL);
     *tabstrip_index = browser->tabstrip_model()->GetIndexOfController(tab);
   }
 }
 
 void TestingAutomationProvider::GetTabURL(int handle,
                                           bool* success,
                                           GURL* url) {
   *success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     // Return what the user would see in the location bar.
     *url = tab->GetActiveEntry()->GetVirtualURL();
     *success = true;
   }
 }
 
 void TestingAutomationProvider::GetShelfVisibility(int handle, bool* visible) {
   *visible = false;
 
   if (browser_tracker_->ContainsHandle(handle)) {
@@ skipping 68 matching lines @@
   new DomOperationMessageSender(this, reply_message, false);
   ExecuteJavascriptInRenderViewFrame(WideToUTF16Hack(frame_xpath),
                                      WideToUTF16Hack(script), reply_message,
                                      web_contents->GetRenderViewHost());
 }
 
 void TestingAutomationProvider::GetConstrainedWindowCount(int handle,
                                                           int* count) {
   *count = -1;  // -1 is the error code
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* nav_controller = tab_tracker_->GetResource(handle);
+    NavigationController* nav_controller = tab_tracker_->GetResource(handle);
     WebContents* web_contents = nav_controller->GetWebContents();
     if (web_contents) {
       TabContentsWrapper* wrapper =
           TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
       if (wrapper) {
         *count = static_cast<int>(wrapper->constrained_window_tab_helper()->
                                   constrained_window_count());
       }
     }
   }
 }
 
 void TestingAutomationProvider::HandleInspectElementRequest(
     int handle, int x, int y, IPC::Message* reply_message) {
   WebContents* web_contents = GetWebContentsForHandle(handle, NULL);
   if (web_contents) {
     DCHECK(!reply_message_);
     reply_message_ = reply_message;
 
     DevToolsWindow::InspectElement(web_contents->GetRenderViewHost(), x, y);
   } else {
     AutomationMsg_InspectElement::WriteReplyParams(reply_message, -1);
     Send(reply_message);
   }
 }
 
 void TestingAutomationProvider::GetDownloadDirectory(
     int handle, FilePath* download_directory) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     DownloadManager* dlm = tab->GetBrowserContext()->GetDownloadManager();
     *download_directory =
         DownloadPrefs::FromDownloadManager(dlm)->download_path();
   }
 }
 
 // Sample json input: { "command": "OpenNewBrowserWindowWithNewProfile" }
 // Sample output: {}
 void TestingAutomationProvider::OpenNewBrowserWindowWithNewProfile(
     base::DictionaryValue* args, IPC::Message* reply_message) {
@@ skipping 73 matching lines @@
       return;
     }
   }
 }
 
 void TestingAutomationProvider::ShowInterstitialPage(
     int tab_handle,
     const std::string& html_text,
     IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* controller =
-        tab_tracker_->GetResource(tab_handle);
+    NavigationController* controller = tab_tracker_->GetResource(tab_handle);
     WebContents* web_contents = controller->GetWebContents();
 
     new NavigationNotificationObserver(controller, this, reply_message, 1,
                                        false, false);
 
     AutomationInterstitialPage* interstitial =
         new AutomationInterstitialPage(static_cast<TabContents*>(web_contents),
                                        GURL("about:interstitial"),
                                        html_text);
     interstitial->Show();
@@ skipping 12 matching lines @@
   if (web_contents && web_contents->GetInterstitialPage()) {
     web_contents->GetInterstitialPage()->DontProceed();
     *success = true;
   }
 }
 
 void TestingAutomationProvider::WaitForTabToBeRestored(
     int tab_handle,
     IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(tab_handle);
+    NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     restore_tracker_.reset(
         new NavigationControllerRestoredObserver(this, tab, reply_message));
   } else {
     AutomationMsg_WaitForTabToBeRestored::WriteReplyParams(
         reply_message, false);
     Send(reply_message);
   }
 }
 
 void TestingAutomationProvider::GetSecurityState(
     int handle,
     bool* success,
     content::SecurityStyle* security_style,
     net::CertStatus* ssl_cert_status,
     int* insecure_content_status) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     NavigationEntry* entry = tab->GetActiveEntry();
     *success = true;
     *security_style = entry->GetSSL().security_style;
     *ssl_cert_status = entry->GetSSL().cert_status;
     *insecure_content_status = entry->GetSSL().content_status;
   } else {
     *success = false;
     *security_style = content::SECURITY_STYLE_UNKNOWN;
     *ssl_cert_status = 0;
     *insecure_content_status = 0;
   }
 }
 
 void TestingAutomationProvider::GetPageType(
     int handle,
     bool* success,
     content::PageType* page_type) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     NavigationEntry* entry = tab->GetActiveEntry();
     *page_type = entry->GetPageType();
     *success = true;
     // In order to return the proper result when an interstitial is shown and
     // no navigation entry were created for it we need to ask the TabContents.
     if (*page_type == content::PAGE_TYPE_NORMAL &&
         tab->GetWebContents()->ShowingInterstitialPage())
       *page_type = content::PAGE_TYPE_INTERSTITIAL;
   } else {
     *success = false;
     *page_type = content::PAGE_TYPE_NORMAL;
   }
 }
 
 void TestingAutomationProvider::GetMetricEventDuration(
     const std::string& event_name,
     int* duration_ms) {
   *duration_ms = metric_event_duration_observer_->GetEventDurationMs(
       event_name);
 }
 
 void TestingAutomationProvider::ActionOnSSLBlockingPage(
     int handle,
     bool proceed,
     IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     NavigationEntry* entry = tab->GetActiveEntry();
     if (entry->GetPageType() == content::PAGE_TYPE_INTERSTITIAL) {
       WebContents* web_contents = tab->GetWebContents();
       InterstitialPage* ssl_blocking_page =
           InterstitialPage::GetInterstitialPage(
               static_cast<TabContents*>(web_contents));
       if (ssl_blocking_page) {
         if (proceed) {
           new NavigationNotificationObserver(tab, this, reply_message, 1,
                                              false, false);
@@ skipping 30 matching lines @@
   *menu_item_enabled = false;
   if (browser_tracker_->ContainsHandle(browser_handle)) {
     Browser* browser = browser_tracker_->GetResource(browser_handle);
     *menu_item_enabled =
         browser->command_updater()->IsCommandEnabled(message_num);
   }
 }
 
 void TestingAutomationProvider::PrintNow(int tab_handle,
                                          IPC::Message* reply_message) {
-  content::NavigationController* tab = NULL;
+  NavigationController* tab = NULL;
   WebContents* web_contents = GetWebContentsForHandle(tab_handle, &tab);
   if (web_contents) {
     FindAndActivateTab(tab);
 
     content::NotificationObserver* observer =
         new DocumentPrintedNotificationObserver(this, reply_message);
 
     TabContentsWrapper* wrapper =
         TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
     if (!wrapper->print_view_manager()->PrintNow()) {
@@ skipping 20 matching lines @@
       save_type > SavePackage::SAVE_AS_COMPLETE_HTML) {
     *success = false;
     return;
   }
 
   if (!tab_tracker_->ContainsHandle(tab_handle)) {
     *success = false;
     return;
   }
 
-  content::NavigationController* nav = tab_tracker_->GetResource(tab_handle);
+  NavigationController* nav = tab_tracker_->GetResource(tab_handle);
   Browser* browser = FindAndActivateTab(nav);
   if (!browser->command_updater()->IsCommandEnabled(IDC_SAVE_PAGE)) {
     *success = false;
     return;
   }
 
   nav->GetWebContents()->SavePage(file_name, dir_path, save_type);
   *success = true;
 }
 
@@ skipping 238 matching lines @@
         *success = true;
       }
     }
   }
   *success = false;
 }
 
 void TestingAutomationProvider::GetInfoBarCount(int handle, size_t* count) {
   *count = static_cast<size_t>(-1);  // -1 means error.
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* nav_controller =
-        tab_tracker_->GetResource(handle);
+    NavigationController* nav_controller = tab_tracker_->GetResource(handle);
     if (nav_controller) {
       TabContentsWrapper* wrapper =
           TabContentsWrapper::GetCurrentWrapperForContents(
               nav_controller->GetWebContents());
       *count = wrapper->infobar_tab_helper()->infobar_count();
     }
   }
 }
 
 void TestingAutomationProvider::ClickInfoBarAccept(
     int handle,
     size_t info_bar_index,
     bool wait_for_navigation,
     IPC::Message* reply_message) {
   bool success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* nav_controller =
-        tab_tracker_->GetResource(handle);
+    NavigationController* nav_controller = tab_tracker_->GetResource(handle);
     if (nav_controller) {
       InfoBarTabHelper* infobar_helper =
           TabContentsWrapper::GetCurrentWrapperForContents(
               nav_controller->GetWebContents())->infobar_tab_helper();
       if (info_bar_index < infobar_helper->infobar_count()) {
         if (wait_for_navigation) {
           new NavigationNotificationObserver(nav_controller, this,
                                              reply_message, 1, false, false);
         }
         InfoBarDelegate* delegate =
@@ skipping 18 matching lines @@
 void TestingAutomationProvider::GetLastNavigationTime(
     int handle,
     int64* last_navigation_time) {
   base::Time time(tab_tracker_->GetLastNavigationTime(handle));
   *last_navigation_time = time.ToInternalValue();
 }
 
 void TestingAutomationProvider::WaitForNavigation(int handle,
                                                   int64 last_navigation_time,
                                                   IPC::Message* reply_message) {
-  content::NavigationController* controller = tab_tracker_->GetResource(handle);
+  NavigationController* controller = tab_tracker_->GetResource(handle);
   base::Time time(tab_tracker_->GetLastNavigationTime(handle));
 
   if (time.ToInternalValue() > last_navigation_time || !controller) {
     AutomationMsg_WaitForNavigation::WriteReplyParams(reply_message,
         controller == NULL ? AUTOMATION_MSG_NAVIGATION_ERROR :
                              AUTOMATION_MSG_NAVIGATION_SUCCESS);
     Send(reply_message);
     return;
   }
 
@@ skipping 110 matching lines @@
     return;
   }
 
   // Set up an observer (it will delete itself).
   new AppModalDialogShownObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::GoBackBlockUntilNavigationsComplete(
     int handle, int number_of_navigations, IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = FindAndActivateTab(tab);
     if (browser && browser->command_updater()->IsCommandEnabled(IDC_BACK)) {
       new NavigationNotificationObserver(tab, this, reply_message,
                                          number_of_navigations, false, false);
       browser->GoBack(CURRENT_TAB);
       return;
     }
   }
 
   AutomationMsg_GoBackBlockUntilNavigationsComplete::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::GoForwardBlockUntilNavigationsComplete(
     int handle, int number_of_navigations, IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
-    content::NavigationController* tab = tab_tracker_->GetResource(handle);
+    NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = FindAndActivateTab(tab);
     if (browser && browser->command_updater()->IsCommandEnabled(IDC_FORWARD)) {
       new NavigationNotificationObserver(tab, this, reply_message,
                                          number_of_navigations, false, false);
       browser->GoForward(CURRENT_TAB);
       return;
     }
   }
 
   AutomationMsg_GoForwardBlockUntilNavigationsComplete::WriteReplyParams(
@@ skipping 22 matching lines @@
       else
         browser->window()->GetDownloadShelf()->Close();
 #endif
     }
   }
 }
 
 void TestingAutomationProvider::GetBlockedPopupCount(int handle, int* count) {
   *count = -1;  // -1 is the error code
   if (tab_tracker_->ContainsHandle(handle)) {
-      content::NavigationController* nav_controller =
-          tab_tracker_->GetResource(handle);
+      NavigationController* nav_controller = tab_tracker_->GetResource(handle);
       TabContentsWrapper* tab_contents =
           TabContentsWrapper::GetCurrentWrapperForContents(
               nav_controller->GetWebContents());
       if (tab_contents) {
         BlockedContentTabHelper* blocked_content =
             tab_contents->blocked_content_tab_helper();
         *count = static_cast<int>(blocked_content->GetBlockedContentsCount());
       }
   }
 }
@@ skipping 734 matching lines @@
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int tab_index;
   TabContents* tab_contents = NULL;
   if (!args->GetInteger("tab_index", &tab_index) ||
       !(tab_contents = browser->GetTabContentsAt(tab_index))) {
     reply.SendError("tab_index missing or invalid.");
     return;
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  const content::NavigationController& controller =
-      tab_contents->GetController();
+  const NavigationController& controller = tab_contents->GetController();
   NavigationEntry* nav_entry = controller.GetActiveEntry();
   DCHECK(nav_entry);
 
   // Security info.
   DictionaryValue* ssl = new DictionaryValue;
   std::map<content::SecurityStyle, std::string> style_to_string;
   style_to_string[content::SECURITY_STYLE_UNKNOWN] = "SECURITY_STYLE_UNKNOWN";
   style_to_string[content::SECURITY_STYLE_UNAUTHENTICATED] =
       "SECURITY_STYLE_UNAUTHENTICATED";
   style_to_string[content::SECURITY_STYLE_AUTHENTICATION_BROKEN] =
@@ skipping 543 matching lines @@
   AutocompleteEditModel* model = loc_bar->location_entry()->model();
   model->OnUpOrDownKeyPressed(count);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "OmniboxAcceptInput" }
 void TestingAutomationProvider::OmniboxAcceptInput(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  content::NavigationController& controller =
+  NavigationController& controller =
       browser->GetSelectedWebContents()->GetController();
   new OmniboxAcceptNotificationObserver(&controller, this, reply_message);
   browser->window()->GetLocationBar()->AcceptInput();
 }
 
 // Sample json input: { "command": "GetInstantInfo" }
 void TestingAutomationProvider::GetInstantInfo(Browser* browser,
                                                DictionaryValue* args,
                                                IPC::Message* reply_message) {
   DictionaryValue* info = new DictionaryValue;
@@ skipping 2629 matching lines @@
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   TabContents* tab_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
-  content::NavigationController& controller = tab_contents->GetController();
+  NavigationController& controller = tab_contents->GetController();
   if (!controller.CanGoForward()) {
     DictionaryValue dict;
     dict.SetBoolean("did_go_forward", false);
     AutomationJSONReply(this, reply_message).SendSuccess(&dict);
     return;
   }
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.GoForward();
 }
 
 void TestingAutomationProvider::GoBack(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   TabContents* tab_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
-  content::NavigationController& controller = tab_contents->GetController();
+  NavigationController& controller = tab_contents->GetController();
   if (!controller.CanGoBack()) {
     DictionaryValue dict;
     dict.SetBoolean("did_go_back", false);
     AutomationJSONReply(this, reply_message).SendSuccess(&dict);
     return;
   }
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.GoBack();
 }
 
 void TestingAutomationProvider::ReloadJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   TabContents* tab_contents;
   std::string error;
   if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
-  content::NavigationController& controller = tab_contents->GetController();
+  NavigationController& controller = tab_contents->GetController();
   new NavigationNotificationObserver(&controller, this, reply_message,
                                      1, false, true);
   controller.Reload(false);
 }
 
 void TestingAutomationProvider::CaptureEntirePageJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
@@ skipping 308 matching lines @@
 void TestingAutomationProvider::WaitForInfoBarCount(
     int tab_handle,
     size_t target_count,
     IPC::Message* reply_message) {
   if (!tab_tracker_->ContainsHandle(tab_handle)) {
     AutomationMsg_WaitForInfoBarCount::WriteReplyParams(reply_message_, false);
     Send(reply_message_);
     return;
   }
 
-  content::NavigationController* controller =
-      tab_tracker_->GetResource(tab_handle);
+  NavigationController* controller = tab_tracker_->GetResource(tab_handle);
   if (!controller) {
     AutomationMsg_WaitForInfoBarCount::WriteReplyParams(reply_message_, false);
     Send(reply_message_);
     return;
   }
 
   // The delegate will delete itself.
   new InfoBarCountObserver(this, reply_message,
       TabContentsWrapper::GetCurrentWrapperForContents(
           controller->GetWebContents()), target_count);
 }
 
 // Gets the current used encoding name of the page in the specified tab.
 void TestingAutomationProvider::GetPageCurrentEncoding(
     int tab_handle, std::string* current_encoding) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* nav = tab_tracker_->GetResource(tab_handle);
+    NavigationController* nav = tab_tracker_->GetResource(tab_handle);
     Browser* browser = FindAndActivateTab(nav);
     if (browser->command_updater()->IsCommandEnabled(IDC_ENCODING_MENU))
       *current_encoding = nav->GetWebContents()->GetEncoding();
   }
 }
 
 void TestingAutomationProvider::ShutdownSessionService(int handle,
                                                        bool* result) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
@@ skipping 25 matching lines @@
                              setting);
     }
     *success = true;
   }
 }
 
 void TestingAutomationProvider::LoadBlockedPlugins(int tab_handle,
                                                    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;
     WebContents* contents = nav->GetWebContents();
     if (!contents)
       return;
     RenderViewHost* host = contents->GetRenderViewHost();
     host->Send(new ChromeViewMsg_LoadBlockedPlugins(host->routing_id()));
     *success = true;
   }
 }
 
 void TestingAutomationProvider::ResetToDefaultTheme() {
   ThemeServiceFactory::GetForProfile(profile_)->UseDefaultTheme();
 }
 
 void TestingAutomationProvider::WaitForProcessLauncherThreadToGoIdle(
     IPC::Message* reply_message) {
   new WaitForProcessLauncherThreadToGoIdleObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::GetParentBrowserOfTab(int tab_handle,
                                                       int* browser_handle,
                                                       bool* success) {
   *success = false;
   if (tab_tracker_->ContainsHandle(tab_handle)) {
-    content::NavigationController* controller =
-        tab_tracker_->GetResource(tab_handle);
+    NavigationController* controller = tab_tracker_->GetResource(tab_handle);
     int index;
     Browser* browser = Browser::GetBrowserForController(controller, &index);
     if (browser) {
       *browser_handle = browser_tracker_->Add(browser);
       *success = true;
     }
   }
 }
 
 // TODO(brettw) change this to accept GURLs when history supports it
@@ skipping 16 matching lines @@
 
   Send(reply_message_);
   redirect_query_ = 0;
   reply_message_ = NULL;
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }