Remove TabContents from TabStripModelObserver::TabReplacedAt.

chrome/browser/sessions/session_service.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/sessions/session_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 434 matching lines @@
   if (tab_to_available_range_.find(tab_id.id()) !=
       tab_to_available_range_.end()) {
     std::pair<int, int>& range = tab_to_available_range_[tab_id.id()];
     range.first = std::min(navigation.index(), range.first);
     range.second = std::max(navigation.index(), range.second);
   }
   ScheduleCommand(CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                                    tab_id.id(), navigation));
 }
 
-void SessionService::TabRestored(TabContents* tab, bool pinned) {
-  SessionTabHelper* session_tab_helper =
-      SessionTabHelper::FromWebContents(tab->web_contents());
+void SessionService::TabRestored(WebContents* tab, bool pinned) {
+  SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
   if (!ShouldTrackChangesToWindow(session_tab_helper->window_id()))
     return;
 
   BuildCommandsForTab(session_tab_helper->window_id(), tab, -1,
                       pinned, &pending_commands(), NULL);
   StartSaveTimer();
 }
 
 void SessionService::SetSelectedNavigationIndex(const SessionID& window_id,
                                                 const SessionID& tab_id,
@@ skipping 809 matching lines @@
       }
 
       default:
         VLOG(1) << "Failed reading an unknown command " << command->id();
         return true;
     }
   }
   return true;
 }
 
-void SessionService::BuildCommandsForTab(
-    const SessionID& window_id,
-    TabContents* tab,
-    int index_in_window,
-    bool is_pinned,
-    std::vector<SessionCommand*>* commands,
-    IdToRange* tab_to_available_range) {
+void SessionService::BuildCommandsForTab(const SessionID& window_id,
+                                         WebContents* tab,
+                                         int index_in_window,
+                                         bool is_pinned,
+                                         std::vector<SessionCommand*>* commands,
+                                         IdToRange* tab_to_available_range) {
   DCHECK(tab && commands && window_id.id());
-  SessionTabHelper* session_tab_helper =
-      SessionTabHelper::FromWebContents(tab->web_contents());
+  SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
   const SessionID& session_id(session_tab_helper->session_id());
   commands->push_back(CreateSetTabWindowCommand(window_id, session_id));
 
-  const int current_index =
-      tab->web_contents()->GetController().GetCurrentEntryIndex();
+  const int current_index = tab->GetController().GetCurrentEntryIndex();
   const int min_index = std::max(0,
                                  current_index - max_persist_navigation_count);
   const int max_index =
       std::min(current_index + max_persist_navigation_count,
-               tab->web_contents()->GetController().GetEntryCount());
-  const int pending_index =
-      tab->web_contents()->GetController().GetPendingEntryIndex();
+               tab->GetController().GetEntryCount());
+  const int pending_index = tab->GetController().GetPendingEntryIndex();
   if (tab_to_available_range) {
     (*tab_to_available_range)[session_id.id()] =
         std::pair<int, int>(min_index, max_index);
   }
 
   if (is_pinned) {
     commands->push_back(CreatePinnedStateCommand(session_id, true));
   }
 
   extensions::TabHelper* extensions_tab_helper =
-      extensions::TabHelper::FromWebContents(tab->web_contents());
+      extensions::TabHelper::FromWebContents(tab);
   if (extensions_tab_helper->extension_app()) {
     commands->push_back(
         CreateSetTabExtensionAppIDCommand(
             kCommandSetExtensionAppID, session_id.id(),
             extensions_tab_helper->extension_app()->id()));
   }
 
-  const std::string& ua_override = tab->web_contents()->GetUserAgentOverride();
+  const std::string& ua_override = tab->GetUserAgentOverride();
   if (!ua_override.empty()) {
     commands->push_back(
         CreateSetTabUserAgentOverrideCommand(
             kCommandSetTabUserAgentOverride, session_id.id(), ua_override));
   }
 
   for (int i = min_index; i < max_index; ++i) {
     const NavigationEntry* entry = (i == pending_index) ?
-        tab->web_contents()->GetController().GetPendingEntry() :
-        tab->web_contents()->GetController().GetEntryAtIndex(i);
+        tab->GetController().GetPendingEntry() :
+        tab->GetController().GetEntryAtIndex(i);
     DCHECK(entry);
     if (ShouldTrackEntry(entry->GetVirtualURL())) {
       const TabNavigation navigation =
           TabNavigation::FromNavigationEntry(i, *entry);
       commands->push_back(
           CreateUpdateTabNavigationCommand(
               kCommandUpdateTabNavigation, session_id.id(), navigation));
     }
   }
   commands->push_back(
       CreateSetSelectedNavigationIndexCommand(session_id, current_index));
 
   if (index_in_window != -1) {
     commands->push_back(
         CreateSetTabIndexInWindowCommand(session_id, index_in_window));
   }
 
   // Record the association between the sessionStorage namespace and the tab.
   content::SessionStorageNamespace* session_storage_namespace =
-      tab->web_contents()->GetController().GetDefaultSessionStorageNamespace();
+      tab->GetController().GetDefaultSessionStorageNamespace();
   ScheduleCommand(CreateSessionStorageAssociatedCommand(
       session_tab_helper->session_id(),
       session_storage_namespace->persistent_id()));
 }
 
 void SessionService::BuildCommandsForBrowser(
     Browser* browser,
     std::vector<SessionCommand*>* commands,
     IdToRange* tab_to_available_range,
     std::set<SessionID::id_type>* windows_to_track) {
@@ skipping 16 matching lines @@
 
   if (!browser->app_name().empty()) {
     commands->push_back(CreateSetWindowAppNameCommand(
         kCommandSetWindowAppName,
         browser->session_id().id(),
         browser->app_name()));
   }
 
   windows_to_track->insert(browser->session_id().id());
   for (int i = 0; i < browser->tab_count(); ++i) {
-    TabContents* tab = chrome::GetTabContentsAt(browser, i);
+    WebContents* tab = chrome::GetWebContentsAt(browser, i);
     DCHECK(tab);
     BuildCommandsForTab(browser->session_id(), tab, i,
                         browser->tab_strip_model()->IsTabPinned(i),
                         commands, tab_to_available_range);
   }
 
   commands->push_back(
       CreateSetSelectedTabInWindow(browser->session_id(),
                                    browser->active_index()));
 }
@@ skipping 376 matching lines @@
       contents->GetController().GetDefaultSessionStorageNamespace();
   session_storage_namespace->SetShouldPersist(false);
   SessionTabHelper* session_tab_helper =
       SessionTabHelper::FromWebContents(contents);
   TabClosed(session_tab_helper->window_id(),
             session_tab_helper->session_id(),
             contents->GetClosedByUserGesture());
   RecordSessionUpdateHistogramData(content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                                    &last_updated_tab_closed_time_);
 }