Convert WebContents to return a content::NavigationController instead of the implementation. Upda...

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"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
-#include "content/browser/tab_contents/navigation_controller.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::NavigationEntry;
 using content::UserMetricsAction;
 using content::WebContents;
 
@@ skipping 106 matching lines @@
       ForgetAllOpeners();
     }
     // Anything opened by a link we deem to have an opener.
     data->SetGroup(&selected_contents->tab_contents()->GetController());
   } else if ((add_types & ADD_INHERIT_OPENER) && selected_contents) {
     if (active) {
       // Forget any existing relationships, we don't want to make things too
       // confusing by having multiple groups active at the same time.
       ForgetAllOpeners();
     }
-    data->opener = &selected_contents->tab_contents()->GetController();
+    data->opener = &selected_contents->web_contents()->GetController();
   }
 
   contents_data_.insert(contents_data_.begin() + index, data);
 
   selection_model_.IncrementFrom(index);
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabInsertedAt(contents, index, active));
   TabStripSelectionModel old_model;
   old_model.Copy(selection_model_);
   if (active) {
     selection_model_.SetSelectedIndex(index);
     NotifyIfActiveOrSelectionChanged(selected_contents, false, old_model);
   }
 }
 
 TabContentsWrapper* TabStripModel::ReplaceTabContentsAt(
     int index,
     TabContentsWrapper* new_contents) {
   DCHECK(ContainsIndex(index));
   TabContentsWrapper* old_contents = GetContentsAt(index);
 
   ForgetOpenersAndGroupsReferencing(
-      &(old_contents->tab_contents()->GetController()));
+      &(old_contents->web_contents()->GetController()));
 
   contents_data_[index]->contents = new_contents;
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabReplacedAt(this, old_contents, new_contents, index));
 
   // When the active tab contents is replaced send out selected notification
   // too. We do this as nearly all observers need to treat a replace of the
   // selected contents as selection changing.
   if (active_index() == index) {
@@ skipping 47 matching lines @@
     return NULL;
 
   DCHECK(ContainsIndex(index));
 
   TabContentsWrapper* removed_contents = GetContentsAt(index);
   bool was_selected = IsTabSelected(index);
   int next_selected_index = order_controller_->DetermineNewSelectedIndex(index);
   delete contents_data_.at(index);
   contents_data_.erase(contents_data_.begin() + index);
   ForgetOpenersAndGroupsReferencing(
-      &(removed_contents->tab_contents()->GetController()));
+      &(removed_contents->web_contents()->GetController()));
   if (empty())
     closing_all_ = true;
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabDetachedAt(removed_contents, index));
   if (empty()) {
     selection_model_.Clear();
     // TabDetachedAt() might unregister observers, so send |TabStripEmtpy()| in
     // a second pass.
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_, TabStripEmpty());
   } else {
@@ skipping 165 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;
 }
 
-NavigationController* TabStripModel::GetOpenerOfTabContentsAt(int index) {
+content::NavigationController* TabStripModel::GetOpenerOfTabContentsAt(
+    int index) {
   DCHECK(ContainsIndex(index));
   return contents_data_.at(index)->opener;
 }
 
 int TabStripModel::GetIndexOfNextTabContentsOpenedBy(
-    const NavigationController* opener, int start_index, bool use_group) const {
+    const content::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 NavigationController* opener,
+    const content::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 NavigationController* opener, int start_index) const {
+    const content::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) {
-  NavigationController* opener = contents_data_[index]->group;
+  content::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 NavigationController* opener,
+                                  const content::NavigationController* opener,
                                   bool use_group) {
   return data->opener == opener || (use_group && data->group == opener);
 }
 
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
-    const NavigationController* tab) {
+    const content::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;
   }
 }