TabContentsWrapper -> TabContents, part 13.

chrome/browser/ui/tabs/tab_strip_model.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/browser/ui/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/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_order_controller.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.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"
@@ skipping 72 matching lines @@
 }
 
 bool TabStripModel::HasObserver(TabStripModelObserver* observer) {
   return observers_.HasObserver(observer);
 }
 
 bool TabStripModel::ContainsIndex(int index) const {
   return index >= 0 && index < count();
 }
 
-void TabStripModel::AppendTabContents(TabContentsWrapper* contents,
+void TabStripModel::AppendTabContents(TabContents* contents,
                                       bool foreground) {
   int index = order_controller_->DetermineInsertionIndexForAppending();
   InsertTabContentsAt(index, contents,
                       foreground ? (ADD_INHERIT_GROUP | ADD_ACTIVE) :
                                    ADD_NONE);
 }
 
 void TabStripModel::InsertTabContentsAt(int index,
-                                        TabContentsWrapper* contents,
+                                        TabContents* contents,
                                         int add_types) {
   bool active = add_types & ADD_ACTIVE;
   // Force app tabs to be pinned.
   bool pin =
       contents->extension_tab_helper()->is_app() || add_types & ADD_PINNED;
   index = ConstrainInsertionIndex(index, pin);
 
   // In tab dragging situations, if the last tab in the window was detached
   // then the user aborted the drag, we will have the |closing_all_| member
   // set (see DetachTabContentsAt) which will mess with our mojo here. We need
   // to clear this bit.
   closing_all_ = false;
 
   // Have to get the active contents before we monkey with |contents_|
   // otherwise we run into problems when we try to change the active contents
   // since the old contents and the new contents will be the same...
-  TabContentsWrapper* selected_contents = GetActiveTabContents();
+  TabContents* 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->web_contents()->GetController());
@@ skipping 13 matching lines @@
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabInsertedAt(contents, index, active));
   if (active) {
     TabStripSelectionModel new_model;
     new_model.Copy(selection_model_);
     new_model.SetSelectedIndex(index);
     SetSelection(new_model, NOTIFY_DEFAULT);
   }
 }
 
-TabContentsWrapper* TabStripModel::ReplaceTabContentsAt(
-    int index,
-    TabContentsWrapper* new_contents) {
+TabContents* TabStripModel::ReplaceTabContentsAt(int index,
+                                                 TabContents* new_contents) {
   DCHECK(ContainsIndex(index));
-  TabContentsWrapper* old_contents = GetContentsAt(index);
+  TabContents* old_contents = GetContentsAt(index);
 
   ForgetOpenersAndGroupsReferencing(
       &(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) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       ActiveTabChanged(old_contents, new_contents,
                                        active_index(), false));
   }
   return old_contents;
 }
 
 void TabStripModel::ReplaceNavigationControllerAt(
-    int index, TabContentsWrapper* contents) {
+    int index, TabContents* contents) {
   // This appears to be OK with no flicker since no redraw event
   // occurs between the call to add an additional tab and one to close
   // the previous tab.
   InsertTabContentsAt(index + 1, contents, ADD_ACTIVE | ADD_INHERIT_GROUP);
   std::vector<int> closing_tabs;
   closing_tabs.push_back(index);
   InternalCloseTabs(closing_tabs, CLOSE_NONE);
 }
 
-TabContentsWrapper* TabStripModel::DiscardTabContentsAt(int index) {
+TabContents* TabStripModel::DiscardTabContentsAt(int index) {
   DCHECK(ContainsIndex(index));
-  TabContentsWrapper* null_contents =
-      new TabContentsWrapper(
-          WebContents::Create(profile(),
-                              NULL /* site_instance */,
-                              MSG_ROUTING_NONE,
-                              NULL /* base_tab_contents */,
-                              NULL /* session_storage_namespace */));
-  TabContentsWrapper* old_contents = GetContentsAt(index);
+  TabContents* null_contents = new TabContents(
+      WebContents::Create(profile(),
+                          NULL /* site_instance */,
+                          MSG_ROUTING_NONE,
+                          NULL /* base_tab_contents */,
+                          NULL /* session_storage_namespace */));
+  TabContents* old_contents = GetContentsAt(index);
   // Copy over the state from the navigation controller so we preserve the
   // back/forward history and continue to display the correct title/favicon.
   null_contents->web_contents()->GetController().CopyStateFrom(
       old_contents->web_contents()->GetController());
   // Replace the tab we're discarding with the null version.
   ReplaceTabContentsAt(index, null_contents);
   // Mark the tab so it will reload when we click.
   contents_data_[index]->discarded = true;
   // Discard the old tab's renderer.
   // TODO(jamescook): This breaks script connections with other tabs.
   // We need to find a different approach that doesn't do that, perhaps based
   // on navigation to swappedout://.
   delete old_contents;
   return null_contents;
 }
 
-TabContentsWrapper* TabStripModel::DetachTabContentsAt(int index) {
+TabContents* TabStripModel::DetachTabContentsAt(int index) {
   if (contents_data_.empty())
     return NULL;
 
   DCHECK(ContainsIndex(index));
 
-  TabContentsWrapper* removed_contents = GetContentsAt(index);
+  TabContents* removed_contents = GetContentsAt(index);
   bool was_selected = IsTabSelected(index);
   int next_selected_index = order_controller_->DetermineNewSelectedIndex(index);
   delete contents_data_[index];
   contents_data_.erase(contents_data_.begin() + index);
   ForgetOpenersAndGroupsReferencing(
       &(removed_contents->web_contents()->GetController()));
   if (empty())
     closing_all_ = true;
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabDetachedAt(removed_contents, index));
@@ skipping 94 matching lines @@
   }
   if (selected_mini_count == selected_count)
     return;
 
   // Then move the non-pinned tabs.
   MoveSelectedTabsToImpl(std::max(index, total_mini_count),
                          selected_mini_count,
                          selected_count - selected_mini_count);
 }
 
-TabContentsWrapper* TabStripModel::GetActiveTabContents() const {
+TabContents* TabStripModel::GetActiveTabContents() const {
   return GetTabContentsAt(active_index());
 }
 
-TabContentsWrapper* TabStripModel::GetTabContentsAt(int index) const {
+TabContents* TabStripModel::GetTabContentsAt(int index) const {
   if (ContainsIndex(index))
     return GetContentsAt(index);
   return NULL;
 }
 
-int TabStripModel::GetIndexOfTabContents(
-    const TabContentsWrapper* contents) const {
+int TabStripModel::GetIndexOfTabContents(const TabContents* contents) const {
   int index = 0;
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter, ++index) {
     if ((*iter)->contents == contents)
       return index;
   }
   return kNoTab;
 }
 
-int TabStripModel::GetWrapperIndex(const WebContents* contents) const {
+int TabStripModel::GetIndexOfWebContents(const WebContents* contents) const {
   int index = 0;
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter, ++index) {
     if ((*iter)->contents->web_contents() == contents)
       return index;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfController(
@@ skipping 98 matching lines @@
   for (; iter != end; --iter) {
     next = iter - 1;
     if (next == end)
       break;
     if ((*next)->opener == opener)
       return static_cast<int>(next - contents_data_.begin());
   }
   return kNoTab;
 }
 
-void TabStripModel::TabNavigating(TabContentsWrapper* contents,
+void TabStripModel::TabNavigating(TabContents* contents,
                                   content::PageTransition transition) {
   if (ShouldForgetOpenersForTransition(transition)) {
     // Don't forget the openers if this tab is a New Tab page opened at the
     // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one
     // navigation of one of these transition types before resetting the
     // opener relationships (this allows for the use case of opening a new
     // tab to do a quick look-up of something while viewing a tab earlier in
     // the strip). We can make this heuristic more permissive if need be.
     if (!IsNewTabAtEndOfTabStrip(contents)) {
       // If the user navigates the current tab to another page in any way
       // other than by clicking a link, we want to pro-actively forget all
       // TabStrip opener relationships since we assume they're beginning a
       // different task by reusing the current tab.
       ForgetAllOpeners();
       // In this specific case we also want to reset the group relationship,
       // since it is now technically invalid.
       ForgetGroup(contents);
     }
   }
 }
 
 void TabStripModel::ForgetAllOpeners() {
   // Forget all opener memories so we don't do anything weird with tab
   // re-selection ordering.
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter)
     (*iter)->ForgetOpener();
 }
 
-void TabStripModel::ForgetGroup(TabContentsWrapper* contents) {
+void TabStripModel::ForgetGroup(TabContents* contents) {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
   contents_data_[index]->SetGroup(NULL);
   contents_data_[index]->ForgetOpener();
 }
 
-bool TabStripModel::ShouldResetGroupOnSelect(
-    TabContentsWrapper* contents) const {
+bool TabStripModel::ShouldResetGroupOnSelect(TabContents* contents) const {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->reset_group_on_select;
 }
 
 void TabStripModel::SetTabBlocked(int index, bool blocked) {
   DCHECK(ContainsIndex(index));
   if (contents_data_[index]->blocked == blocked)
     return;
   contents_data_[index]->blocked = blocked;
@@ skipping 44 matching lines @@
 bool TabStripModel::IsTabPinned(int index) const {
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->pinned;
 }
 
 bool TabStripModel::IsMiniTab(int index) const {
   return IsTabPinned(index) || IsAppTab(index);
 }
 
 bool TabStripModel::IsAppTab(int index) const {
-  TabContentsWrapper* contents = GetTabContentsAt(index);
+  TabContents* contents = GetTabContentsAt(index);
   return contents && contents->extension_tab_helper()->is_app();
 }
 
 bool TabStripModel::IsTabBlocked(int index) const {
   return contents_data_[index]->blocked;
 }
 
 bool TabStripModel::IsTabDiscarded(int index) const {
   return contents_data_[index]->discarded;
 }
@@ skipping 54 matching lines @@
   DCHECK(ContainsIndex(index));
   return selection_model_.IsSelected(index);
 }
 
 void TabStripModel::SetSelectionFromModel(
     const TabStripSelectionModel& source) {
   DCHECK_NE(TabStripSelectionModel::kUnselectedIndex, source.active());
   SetSelection(source, NOTIFY_DEFAULT);
 }
 
-void TabStripModel::AddTabContents(TabContentsWrapper* contents,
+void TabStripModel::AddTabContents(TabContents* contents,
                                    int index,
                                    content::PageTransition transition,
                                    int add_types) {
   // If the newly-opened tab is part of the same task as the parent tab, we want
   // to inherit the parent's "group" attribute, so that if this tab is then
   // closed we'll jump back to the parent tab.
   bool inherit_group = (add_types & ADD_INHERIT_GROUP) == ADD_INHERIT_GROUP;
 
   if (transition == content::PAGE_TRANSITION_LINK &&
       (add_types & ADD_FORCE_INDEX) == 0) {
@@ skipping 33 matching lines @@
   // TODO(sky): figure out why this is here and not in InsertTabContentsAt. When
   // here we seem to get failures in startup perf tests.
   // Ensure that the new WebContentsView begins at the same size as the
   // previous WebContentsView if it existed.  Otherwise, the initial WebKit
   // layout will be performed based on a width of 0 pixels, causing a
   // very long, narrow, inaccurate layout.  Because some scripts on pages (as
   // well as WebKit's anchor link location calculation) are run on the
   // initial layout and not recalculated later, we need to ensure the first
   // layout is performed with sane view dimensions even when we're opening a
   // new background tab.
-  if (TabContentsWrapper* old_contents = GetActiveTabContents()) {
+  if (TabContents* old_contents = GetActiveTabContents()) {
     if ((add_types & ADD_ACTIVE) == 0) {
       contents->web_contents()->GetView()->
           SizeContents(old_contents->web_contents()->
               GetView()->GetContainerSize());
       // We need to hide the contents or else we get and execute paints for
       // background tabs. With enough background tabs they will steal the
       // backing store of the visible tab causing flashing. See bug 20831.
       contents->web_contents()->HideContents();
     }
   }
@@ skipping 39 matching lines @@
   switch (command_id) {
     case CommandNewTab:
       return true;
 
     case CommandCloseTab:
       return delegate_->CanCloseTab();
 
     case CommandReload: {
       std::vector<int> indices = GetIndicesForCommand(context_index);
       for (size_t i = 0; i < indices.size(); ++i) {
-        TabContentsWrapper* tab = GetTabContentsAt(indices[i]);
+        TabContents* tab = GetTabContentsAt(indices[i]);
         if (tab && tab->web_contents()->GetDelegate()->CanReloadContents(
                 tab->web_contents())) {
           return true;
         }
       }
       return false;
     }
 
     case CommandCloseOtherTabs:
     case CommandCloseTabsToRight:
@@ skipping 40 matching lines @@
   switch (command_id) {
     case CommandNewTab:
       content::RecordAction(UserMetricsAction("TabContextMenu_NewTab"));
       delegate()->AddBlankTabAt(context_index + 1, true);
       break;
 
     case CommandReload: {
       content::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]);
+        TabContents* tab = GetTabContentsAt(indices[i]);
         if (tab && tab->web_contents()->GetDelegate()->CanReloadContents(
                 tab->web_contents())) {
           tab->web_contents()->GetController().Reload(true);
         }
       }
       break;
     }
 
     case CommandDuplicate: {
       content::RecordAction(UserMetricsAction("TabContextMenu_Duplicate"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
-      // Copy the TabContentsWrapper off as the indices will change as tabs are
+      // Copy the TabContents off as the indices will change as tabs are
       // duplicated.
-      std::vector<TabContentsWrapper*> tabs;
+      std::vector<TabContents*> tabs;
       for (size_t i = 0; i < indices.size(); ++i)
         tabs.push_back(GetTabContentsAt(indices[i]));
       for (size_t i = 0; i < tabs.size(); ++i) {
         int index = GetIndexOfTabContents(tabs[i]);
         if (index != -1 && delegate_->CanDuplicateContentsAt(index))
           delegate_->DuplicateContentsAt(index);
       }
       break;
     }
 
     case CommandCloseTab: {
       content::RecordAction(UserMetricsAction("TabContextMenu_CloseTab"));
       std::vector<int> indices = GetIndicesForCommand(context_index);
-      // Copy the TabContentsWrapper off as the indices will change as we remove
+      // Copy the TabContents off as the indices will change as we remove
       // things.
-      std::vector<TabContentsWrapper*> tabs;
+      std::vector<TabContents*> tabs;
       for (size_t i = 0; i < indices.size(); ++i)
         tabs.push_back(GetTabContentsAt(indices[i]));
       for (size_t i = 0; i < tabs.size() && delegate_->CanCloseTab(); ++i) {
         int index = GetIndexOfTabContents(tabs[i]);
         if (index != -1) {
           CloseTabContentsAt(index,
                              CLOSE_CREATE_HISTORICAL_TAB | CLOSE_USER_GESTURE);
         }
       }
       break;
@@ skipping 112 matching lines @@
 
 void TabStripModel::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
       // Sometimes, on qemu, it seems like a WebContents object can be destroyed
       // while we still have a reference to it. We need to break this reference
       // here so we don't crash later.
       int index = GetIndexOfTabContents(
-          content::Source<TabContentsWrapper>(source).ptr());
+          content::Source<TabContents>(source).ptr());
       if (index != TabStripModel::kNoTab) {
         // Note that we only detach the contents here, not close it - it's
         // already been closed. We just want to undo our bookkeeping.
         DetachTabContentsAt(index);
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const extensions::Extension* extension =
           content::Details<extensions::UnloadedExtensionInfo>(
               details)->extension;
       // Iterate backwards as we may remove items while iterating.
       for (int i = count() - 1; i >= 0; i--) {
-        TabContentsWrapper* contents = GetTabContentsAt(i);
+        TabContents* contents = GetTabContentsAt(i);
         if (contents->extension_tab_helper()->extension_app() == extension) {
           // The extension an app tab was created from has been nuked. Delete
           // the WebContents. Deleting a WebContents results in a notification
           // of type NOTIFICATION_WEB_CONTENTS_DESTROYED; we do the necessary
           // cleanup in handling that notification.
 
           InternalCloseTab(contents, i, false);
         }
       }
       break;
@@ skipping 32 matching lines @@
   }
 
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, private:
 
 void TabStripModel::GetIndicesWithSameDomain(int index,
                                              std::vector<int>* indices) {
-  TabContentsWrapper* tab = GetTabContentsAt(index);
+  TabContents* tab = GetTabContentsAt(index);
   std::string domain = tab->web_contents()->GetURL().host();
   if (domain.empty())
     return;
   for (int i = 0; i < count(); ++i) {
     if (i == index)
       continue;
     if (GetTabContentsAt(i)->web_contents()->GetURL().host() == domain)
       indices->push_back(i);
   }
 }
@@ skipping 19 matching lines @@
 
 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 {
+bool TabStripModel::IsNewTabAtEndOfTabStrip(TabContents* contents) const {
   const GURL& url = contents->web_contents()->GetURL();
   return url.SchemeIs(chrome::kChromeUIScheme) &&
          url.host() == chrome::kChromeUINewTabHost &&
          contents == GetContentsAt(count() - 1) &&
          contents->web_contents()->GetController().GetEntryCount() == 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())
     return retval;
 
-  // Map the indices to TabContentsWrapper, that way if deleting a tab deletes
+  // Map the indices to TabContents, that way if deleting a tab deletes
   // other tabs we're ok. Crashes seem to indicate during tab deletion other
   // tabs are getting removed.
-  std::vector<TabContentsWrapper*> tabs;
+  std::vector<TabContents*> tabs;
   for (size_t i = 0; i < indices.size(); ++i)
     tabs.push_back(GetContentsAt(indices[i]));
 
   // We only try the fast shutdown path if the whole browser process is *not*
   // shutting down. Fast shutdown during browser termination is handled in
   // BrowserShutdown.
   if (browser_shutdown::GetShutdownType() == browser_shutdown::NOT_VALID) {
     // Construct a map of processes to the number of associated tabs that are
     // closing.
     std::map<content::RenderProcessHost*, size_t> processes;
     for (size_t i = 0; i < indices.size(); ++i) {
-      TabContentsWrapper* detached_contents = GetContentsAt(indices[i]);
+      TabContents* detached_contents = GetContentsAt(indices[i]);
       content::RenderProcessHost* process =
           detached_contents->web_contents()->GetRenderProcessHost();
       std::map<content::RenderProcessHost*, size_t>::iterator iter =
           processes.find(process);
       if (iter == processes.end()) {
         processes[process] = 1;
       } else {
         iter->second++;
       }
     }
 
     // Try to fast shutdown the tabs that can close.
     for (std::map<content::RenderProcessHost*, size_t>::iterator iter =
             processes.begin();
         iter != processes.end(); ++iter) {
       iter->first->FastShutdownForPageCount(iter->second);
     }
   }
 
   // We now return to our regularly scheduled shutdown procedure.
   for (size_t i = 0; i < tabs.size(); ++i) {
-    TabContentsWrapper* detached_contents = tabs[i];
+    TabContents* detached_contents = tabs[i];
     int index = GetIndexOfTabContents(detached_contents);
     // Make sure we still contain the tab.
     if (index == kNoTab)
       continue;
 
     detached_contents->web_contents()->OnCloseStarted();
 
     // Update the explicitly closed state. If the unload handlers cancel the
     // close the state is reset in Browser. We don't update the explicitly
     // closed state if already marked as explicitly closed as unload handlers
     // call back to this if the close is allowed.
     if (!detached_contents->web_contents()->GetClosedByUserGesture()) {
       detached_contents->web_contents()->SetClosedByUserGesture(
           close_types & CLOSE_USER_GESTURE);
     }
 
     if (delegate_->RunUnloadListenerBeforeClosing(detached_contents)) {
       retval = false;
       continue;
     }
 
     InternalCloseTab(detached_contents, index,
                      (close_types & CLOSE_CREATE_HISTORICAL_TAB) != 0);
   }
 
   return retval;
 }
 
-void TabStripModel::InternalCloseTab(TabContentsWrapper* contents,
+void TabStripModel::InternalCloseTab(TabContents* contents,
                                      int index,
                                      bool create_historical_tabs) {
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabClosingAt(this, contents, index));
 
   // Ask the delegate to save an entry for this tab in the historical tab
   // database if applicable.
   if (create_historical_tabs)
     delegate_->CreateHistoricalTab(contents);
 
-  // Deleting the TabContentsWrapper will call back to us via
+  // Deleting the TabContents will call back to us via
   // NotificationObserver and detach it.
   delete contents;
 }
 
-TabContentsWrapper* TabStripModel::GetContentsAt(int index) const {
+TabContents* TabStripModel::GetContentsAt(int index) const {
   CHECK(ContainsIndex(index)) <<
       "Failed to find: " << index << " in: " << count() << " entries.";
   return contents_data_[index]->contents;
 }
 
-void TabStripModel::NotifyIfTabDeactivated(TabContentsWrapper* contents) {
+void TabStripModel::NotifyIfTabDeactivated(TabContents* contents) {
   if (contents) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       TabDeactivated(contents));
   }
 }
 
-void TabStripModel::NotifyIfActiveTabChanged(
-    TabContentsWrapper* old_contents,
-    NotifyTypes notify_types) {
-  TabContentsWrapper* new_contents = GetContentsAt(active_index());
+void TabStripModel::NotifyIfActiveTabChanged(TabContents* old_contents,
+                                             NotifyTypes notify_types) {
+  TabContents* new_contents = GetContentsAt(active_index());
   if (old_contents != new_contents) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       ActiveTabChanged(old_contents, new_contents,
                                        active_index(),
                                        notify_types == NOTIFY_USER_GESTURE));
     // Activating a discarded tab reloads it, so it is no longer discarded.
     contents_data_[active_index()]->discarded = false;
   }
 }
 
 void TabStripModel::NotifyIfActiveOrSelectionChanged(
-    TabContentsWrapper* old_contents,
+    TabContents* old_contents,
     NotifyTypes notify_types,
     const TabStripSelectionModel& old_model) {
   NotifyIfActiveTabChanged(old_contents, notify_types);
 
   if (!selection_model().Equals(old_model)) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       TabSelectionChanged(this, old_model));
   }
 }
 
 void TabStripModel::SetSelection(
     const TabStripSelectionModel& new_model,
     NotifyTypes notify_types) {
-  TabContentsWrapper* old_contents = GetActiveTabContents();
+  TabContents* old_contents = GetActiveTabContents();
   TabStripSelectionModel old_model;
   old_model.Copy(selection_model_);
   if (new_model.active() != selection_model_.active())
     NotifyIfTabDeactivated(old_contents);
   selection_model_.Copy(new_model);
   NotifyIfActiveOrSelectionChanged(old_contents, notify_types, old_model);
 }
 
 void TabStripModel::SelectRelativeTab(bool next) {
   // This may happen during automated testing or if a user somehow buffers
@@ skipping 70 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;
   }
 }