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

chrome/test/base/ui_test_utils.cc

 // Copyright (c) 2012 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/test/base/ui_test_utils.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 50 matching lines @@
 #include "ui/gfx/size.h"
 
 #if defined(TOOLKIT_VIEWS)
 #include "ui/views/focus/accelerator_handler.h"
 #endif
 
 #if defined(USE_AURA)
 #include "ui/aura/root_window.h"
 #endif
 
+using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
 
 static const int kDefaultWsPort = 8880;
 
 namespace ui_test_utils {
 
 namespace {
@@ skipping 226 matching lines @@
   WebContents* web_contents = browser->GetSelectedWebContents();
   if (!web_contents)
     return false;
   NavigationEntry* last_entry = web_contents->GetController().GetActiveEntry();
   if (!last_entry)
     return false;
   title->assign(last_entry->GetTitleForDisplay(""));
   return true;
 }
 
-void WaitForNavigations(content::NavigationController* controller,
+void WaitForNavigations(NavigationController* controller,
                         int number_of_navigations) {
   TestNavigationObserver observer(
-      content::Source<content::NavigationController>(controller), NULL,
+      content::Source<NavigationController>(controller), NULL,
       number_of_navigations);
   observer.WaitForObservation(
       base::Bind(&ui_test_utils::RunMessageLoop),
       base::Bind(&MessageLoop::Quit,
                  base::Unretained(MessageLoopForUI::current())));
 }
 
 void WaitForNewTab(Browser* browser) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, content::NOTIFICATION_TAB_ADDED,
                   content::Source<content::WebContentsDelegate>(browser));
 }
 
 void WaitForBrowserActionUpdated(ExtensionAction* browser_action) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer,
                   chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
                   content::Source<ExtensionAction>(browser_action));
 }
 
 void WaitForLoadStop(WebContents* tab) {
   WindowedNotificationObserver load_stop_observer(
       content::NOTIFICATION_LOAD_STOP,
-      content::Source<content::NavigationController>(&tab->GetController()));
+      content::Source<NavigationController>(&tab->GetController()));
   // In many cases, the load may have finished before we get here.  Only wait if
   // the tab still has a pending navigation.
   if (!tab->IsLoading())
     return;
   load_stop_observer.Wait();
 }
 
 Browser* WaitForNewBrowser() {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
@@ skipping 40 matching lines @@
 // |disposition| indicates what tab the download occurs in, and
 // |browser_test_flags| controls what to wait for before continuing.
 static void NavigateToURLWithDispositionBlockUntilNavigationsComplete(
     Browser* browser,
     const GURL& url,
     int number_of_navigations,
     WindowOpenDisposition disposition,
     int browser_test_flags) {
   if (disposition == CURRENT_TAB && browser->GetSelectedWebContents())
     WaitForLoadStop(browser->GetSelectedWebContents());
-  content::NavigationController* controller =
+  NavigationController* controller =
       browser->GetSelectedWebContents() ?
       &browser->GetSelectedWebContents()->GetController() : NULL;
   TestNavigationObserver same_tab_observer(
-      content::Source<content::NavigationController>(controller),
+      content::Source<NavigationController>(controller),
       NULL,
       number_of_navigations);
 
   std::set<Browser*> initial_browsers;
   for (std::vector<Browser*>::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end();
        ++iter) {
     initial_browsers.insert(*iter);
   }
 
@@ skipping 25 matching lines @@
     // The currently selected tab is the right one.
     web_contents = browser->GetSelectedWebContents();
   }
   if (disposition == CURRENT_TAB) {
     same_tab_observer.WaitForObservation(
         base::Bind(&ui_test_utils::RunMessageLoop),
         base::Bind(&MessageLoop::Quit,
                    base::Unretained(MessageLoopForUI::current())));
     return;
   } else if (web_contents) {
-    content::NavigationController* controller = &web_contents->GetController();
+    NavigationController* controller = &web_contents->GetController();
     WaitForNavigations(controller, number_of_navigations);
     return;
   }
   EXPECT_TRUE(NULL != web_contents) << " Unable to wait for navigation to \""
                                     << url.spec() << "\""
                                     << " because we can't get the tab contents";
 }
 
 void NavigateToURLWithDisposition(Browser* browser,
                                   const GURL& url,
@@ skipping 458 matching lines @@
                               content::Source<WebContents>(web_contents));
 
   // When navigating through the history, the restored NavigationEntry's title
   // will be used. If the entry ends up having the same title after we return
   // to it, as will usually be the case, the
   // NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED will then be suppressed, since the
   // NavigationEntry's title hasn't changed.
   notification_registrar_.Add(
       this,
       content::NOTIFICATION_LOAD_STOP,
-      content::Source<content::NavigationController>(
-          &web_contents->GetController()));
+      content::Source<NavigationController>(&web_contents->GetController()));
 }
 
 void TitleWatcher::AlsoWaitForTitle(const string16& expected_title) {
   expected_titles_.push_back(expected_title);
 }
 
 TitleWatcher::~TitleWatcher() {
 }
 
 const string16& TitleWatcher::WaitAndGetTitle() {
   if (expected_title_observed_)
     return observed_title_;
   quit_loop_on_observation_ = true;
   ui_test_utils::RunMessageLoop();
   return observed_title_;
 }
 
 void TitleWatcher::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   if (type == content::NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED) {
     WebContents* source_contents = content::Source<WebContents>(source).ptr();
     ASSERT_EQ(web_contents_, source_contents);
   } else if (type == content::NOTIFICATION_LOAD_STOP) {
-    content::NavigationController* controller =
-        content::Source<content::NavigationController>(source).ptr();
+    NavigationController* controller =
+        content::Source<NavigationController>(source).ptr();
     ASSERT_EQ(&web_contents_->GetController(), controller);
   } else {
     FAIL() << "Unexpected notification received.";
   }
 
   std::vector<string16>::const_iterator it =
       std::find(expected_titles_.begin(),
                 expected_titles_.end(),
                 web_contents_->GetTitle());
   if (it == expected_titles_.end())
@@ skipping 109 matching lines @@
   return taker.TakeRenderWidgetSnapshot(rwh, page_size, page_size, bitmap);
 }
 
 bool TakeEntirePageSnapshot(RenderViewHost* rvh, SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeEntirePageSnapshot(rvh, bitmap);
 }
 
 }  // namespace ui_test_utils