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

chrome/browser/tabs/tab_strip_model.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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/command_line.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_delegate.h"
 
+using content::NavigationController;
 using content::NavigationEntry;
 using content::UserMetricsAction;
 using content::WebContents;
 
 namespace {
 
 // Returns true if the specified transition is one of the types that cause the
 // opener relationships for the tab in which the transition occured to be
 // forgotten. This is generally any navigation that isn't a link click (i.e.
 // any navigation that can be considered to be the start of a new task distinct
@@ skipping 334 matching lines @@
   int index = 0;
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter, ++index) {
     if ((*iter)->contents->tab_contents() == contents)
       return index;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfController(
-    const content::NavigationController* controller) const {
+    const NavigationController* controller) const {
   int index = 0;
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter, ++index) {
     if (&(*iter)->contents->tab_contents()->GetController() == controller)
       return index;
   }
   return kNoTab;
 }
 
 void TabStripModel::UpdateTabContentsStateAt(int index,
@@ skipping 23 matching lines @@
 
 bool TabStripModel::TabsAreLoading() const {
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter) {
     if ((*iter)->contents->tab_contents()->IsLoading())
       return true;
   }
   return false;
 }
 
-content::NavigationController* TabStripModel::GetOpenerOfTabContentsAt(
-    int index) {
+NavigationController* TabStripModel::GetOpenerOfTabContentsAt(int index) {
   DCHECK(ContainsIndex(index));
   return contents_data_.at(index)->opener;
 }
 
 int TabStripModel::GetIndexOfNextTabContentsOpenedBy(
-    const content::NavigationController* opener,
+    const NavigationController* opener,
     int start_index,
     bool use_group) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   // Check tabs after start_index first.
   for (int i = start_index + 1; i < count(); ++i) {
     if (OpenerMatches(contents_data_[i], opener, use_group))
       return i;
   }
   // Then check tabs before start_index, iterating backwards.
   for (int i = start_index - 1; i >= 0; --i) {
     if (OpenerMatches(contents_data_[i], opener, use_group))
       return i;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfFirstTabContentsOpenedBy(
-    const content::NavigationController* opener,
-    int start_index) const {
+    const NavigationController* opener, int start_index) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   for (int i = 0; i < start_index; ++i) {
     if (contents_data_[i]->opener == opener)
       return i;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfLastTabContentsOpenedBy(
-    const content::NavigationController* opener, int start_index) const {
+    const NavigationController* opener, int start_index) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   TabContentsDataVector::const_iterator end =
       contents_data_.begin() + start_index;
   TabContentsDataVector::const_iterator iter = contents_data_.end();
   TabContentsDataVector::const_iterator next;
   for (; iter != end; --iter) {
     next = iter - 1;
     if (next == end)
@@ skipping 599 matching lines @@
   for (int i = 0; i < count(); ++i) {
     if (i == index)
       continue;
     if (GetTabContentsAt(i)->tab_contents()->GetURL().host() == domain)
       indices->push_back(i);
   }
 }
 
 void TabStripModel::GetIndicesWithSameOpener(int index,
                                              std::vector<int>* indices) {
-  content::NavigationController* opener = contents_data_[index]->group;
+  NavigationController* opener = contents_data_[index]->group;
   if (!opener) {
     // If there is no group, find all tabs with the selected tab as the opener.
     opener = &(GetTabContentsAt(index)->tab_contents()->GetController());
     if (!opener)
       return;
   }
   for (int i = 0; i < count(); ++i) {
     if (i == index)
       continue;
     if (contents_data_[i]->group == opener ||
@@ skipping 208 matching lines @@
       MoveTabContentsAt(selection_model_.selected_indices()[tab_index],
                         target_index, false);
     }
     tab_index++;
     target_index++;
   }
 }
 
 // static
 bool TabStripModel::OpenerMatches(const TabContentsData* data,
-                                  const content::NavigationController* opener,
+                                  const NavigationController* opener,
                                   bool use_group) {
   return data->opener == opener || (use_group && data->group == opener);
 }
 
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
-    const content::NavigationController* tab) {
+    const NavigationController* tab) {
   for (TabContentsDataVector::const_iterator i = contents_data_.begin();
        i != contents_data_.end(); ++i) {
     if ((*i)->group == tab)
       (*i)->group = NULL;
     if ((*i)->opener == tab)
       (*i)->opener = NULL;
   }
 }