TabContents -> WebContentsImpl, part 20.

chrome/browser/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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/command_line.h"
@@ skipping 842 matching lines @@
                 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 TabContents off as the indices will change as tabs are
+      // Copy the TabContentsWrapper off as the indices will change as tabs are
       // duplicated.
       std::vector<TabContentsWrapper*> 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 TabContents off as the indices will change as we remove
+      // Copy the TabContentsWrapper off as the indices will change as we remove
       // things.
       std::vector<TabContentsWrapper*> 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);
         }
@@ skipping 110 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, content::NotificationObserver implementation:
 
 void TabStripModel::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
-      // Sometimes, on qemu, it seems like a TabContents object can be 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 = GetWrapperIndex(content::Source<WebContents>(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 Extension* extension =
           content::Details<UnloadedExtensionInfo>(details)->extension;
       // Iterate backwards as we may remove items while iterating.
       for (int i = count() - 1; i >= 0; i--) {
         TabContentsWrapper* contents = GetTabContentsAt(i);
         if (contents->extension_tab_helper()->extension_app() == extension) {
           // The extension an app tab was created from has been nuked. Delete
-          // the TabContents. Deleting a TabContents results in a notification
-          // of type TAB_CONTENTS_DESTROYED; we do the necessary cleanup in
-          // handling that notification.
+          // 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;
     }
 
     default:
       NOTREACHED();
   }
@@ skipping 86 matching lines @@
 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 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.
+  // Map the indices to TabContentsWrapper, 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;
   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.
@@ skipping 54 matching lines @@
                                      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 TabContents will call back to us via NotificationObserver
-  // and detach it.
+  // Deleting the TabContentsWrapper will call back to us via
+  // NotificationObserver and detach it.
   delete contents;
 }
 
 TabContentsWrapper* TabStripModel::GetContentsAt(int index) const {
   CHECK(ContainsIndex(index)) <<
       "Failed to find: " << index << " in: " << count() << " entries.";
   return contents_data_.at(index)->contents;
 }
 
 void TabStripModel::NotifyIfTabDeactivated(TabContentsWrapper* contents) {
@@ skipping 116 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;
   }
 }