Clean up TCW, make it solely a hub for 1:1 observer/helper objects.

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 124 matching lines @@
   TabContentsWrapper* selected_contents = GetActiveTabContents();
   TabContentsData* data = new TabContentsData(contents);
   data->pinned = pin;
   if ((add_types & ADD_INHERIT_GROUP) && 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();
     }
     // Anything opened by a link we deem to have an opener.
-    data->SetGroup(&selected_contents->controller());
+    data->SetGroup(&selected_contents->tab_contents()->controller());
   } 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->controller();
+    data->opener = &selected_contents->tab_contents()->controller();
   }
 
   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->controller()));
+  ForgetOpenersAndGroupsReferencing(
+      &(old_contents->tab_contents()->controller()));
 
   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 18 matching lines @@
 TabContentsWrapper* TabStripModel::DiscardTabContentsAt(int index) {
   DCHECK(ContainsIndex(index));
   TabContentsWrapper* null_contents =
       new TabContentsWrapper(
           new TabContents(profile(),
                           NULL /* site_instance */,
                           MSG_ROUTING_NONE,
                           NULL /* base_tab_contents */,
                           NULL /* session_storage_namespace */));
   TabContentsWrapper* old_contents = GetContentsAt(index);
-  NavigationEntry* old_nav_entry = old_contents->controller().GetActiveEntry();
+  NavigationEntry* old_nav_entry =
+      old_contents->tab_contents()->controller().GetActiveEntry();
   if (old_nav_entry) {
     // Set the new tab contents to reload this URL when clicked.
     // This also allows the tab to keep drawing the favicon and page title.
     NavigationEntry* new_nav_entry = new NavigationEntry(*old_nav_entry);
     std::vector<NavigationEntry*> entries;
     entries.push_back(new_nav_entry);
-    null_contents->controller().Restore(0, false, &entries);
+    null_contents->tab_contents()->controller().Restore(0, false, &entries);
   }
   ReplaceTabContentsAt(index, null_contents);
   // Mark the tab so it will reload when we click.
   contents_data_[index]->discarded = true;
   delete old_contents;
   return null_contents;
 }
 
 TabContentsWrapper* TabStripModel::DetachTabContentsAt(int index) {
   if (contents_data_.empty())
     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->controller()));
+  ForgetOpenersAndGroupsReferencing(
+      &(removed_contents->tab_contents()->controller()));
   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 125 matching lines @@
       return index;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfController(
     const NavigationController* controller) const {
   int index = 0;
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter, ++index) {
-    if (&(*iter)->contents->controller() == controller)
+    if (&(*iter)->contents->tab_contents()->controller() == controller)
       return index;
   }
   return kNoTab;
 }
 
 void TabStripModel::UpdateTabContentsStateAt(int index,
     TabStripModelObserver::TabChangeType change_type) {
   DCHECK(ContainsIndex(index));
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
@@ skipping 436 matching lines @@
       delegate()->AddBlankTabAt(context_index + 1, true);
       break;
 
     case CommandReload: {
       UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_Reload"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       for (size_t i = 0; i < indices.size(); ++i) {
         TabContentsWrapper* tab = GetTabContentsAt(indices[i]);
         if (tab && tab->tab_contents()->delegate()->CanReloadContents(
                 tab->tab_contents())) {
-          tab->controller().Reload(true);
+          tab->tab_contents()->controller().Reload(true);
         }
       }
       break;
     }
 
     case CommandDuplicate: {
       UserMetrics::RecordAction(UserMetricsAction("TabContextMenu_Duplicate"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
       // Copy the TabContents off as the indices will change as tabs are
       // duplicated.
@@ skipping 222 matching lines @@
     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;
   if (!opener) {
     // If there is no group, find all tabs with the selected tab as the opener.
-    opener = &(GetTabContentsAt(index)->controller());
+    opener = &(GetTabContentsAt(index)->tab_contents()->controller());
     if (!opener)
       return;
   }
   for (int i = 0; i < count(); ++i) {
     if (i == index)
       continue;
     if (contents_data_[i]->group == opener ||
-        &(GetTabContentsAt(i)->controller()) == opener) {
+        &(GetTabContentsAt(i)->tab_contents()->controller()) == opener) {
       indices->push_back(i);
     }
   }
 }
 
 std::vector<int> TabStripModel::GetIndicesForCommand(int index) const {
   if (!IsTabSelected(index)) {
     std::vector<int> indices;
     indices.push_back(index);
     return indices;
   }
   return selection_model_.selected_indices();
 }
 
 bool TabStripModel::IsNewTabAtEndOfTabStrip(
     TabContentsWrapper* contents) const {
   const GURL& url = contents->tab_contents()->GetURL();
   return url.SchemeIs(chrome::kChromeUIScheme) &&
          url.host() == chrome::kChromeUINewTabHost &&
          contents == GetContentsAt(count() - 1) &&
-         contents->controller().entry_count() == 1;
+         contents->tab_contents()->controller().entry_count() == 1;
 }
 
 bool TabStripModel::InternalCloseTabs(const std::vector<int>& in_indices,
                                       uint32 close_types) {
   if (in_indices.empty())
     return true;
 
   std::vector<int> indices(in_indices);
   bool retval = delegate_->CanCloseContents(&indices);
   if (indices.empty())
@@ skipping 191 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     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;
   }
 }