TabContentsWrapper -> TabContents, part 26.

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 11 matching lines @@
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.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.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_MACOSX)
@@ skipping 393 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(index, range.first);
     range.second = std::max(index, range.second);
   }
   ScheduleCommand(CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                                    tab_id.id(), index, entry));
 }
 
-void SessionService::TabRestored(TabContentsWrapper* tab, bool pinned) {
+void SessionService::TabRestored(TabContents* tab, bool pinned) {
   if (!ShouldTrackChangesToWindow(tab->restore_tab_helper()->window_id()))
     return;
 
   BuildCommandsForTab(tab->restore_tab_helper()->window_id(), tab, -1,
                       pinned, &pending_commands(), NULL);
   StartSaveTimer();
 }
 
 void SessionService::SetSelectedNavigationIndex(const SessionID& window_id,
                                                 const SessionID& tab_id,
@@ skipping 124 matching lines @@
           !should_track_changes_for_browser_type(browser->type(), app_type))
         return;
 
       RestoreIfNecessary(std::vector<GURL>(), browser);
       SetWindowType(browser->session_id(), browser->type(), app_type);
       SetWindowAppName(browser->session_id(), browser->app_name());
       break;
     }
 
     case chrome::NOTIFICATION_TAB_PARENTED: {
-      TabContentsWrapper* tab =
-          content::Source<TabContentsWrapper>(source).ptr();
+      TabContents* tab = content::Source<TabContents>(source).ptr();
       if (tab->profile() != profile())
         return;
       SetTabWindow(tab->restore_tab_helper()->window_id(),
                    tab->restore_tab_helper()->session_id());
       if (tab->extension_tab_helper()->extension_app()) {
         SetTabExtensionAppID(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->extension_tab_helper()->extension_app()->id());
       }
       break;
     }
 
     case chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
-      TabContentsWrapper* tab =
-          content::Source<TabContentsWrapper>(source).ptr();
+      TabContents* tab = content::Source<TabContents>(source).ptr();
       if (!tab || tab->profile() != profile())
         return;
       TabClosed(tab->restore_tab_helper()->window_id(),
                 tab->restore_tab_helper()->session_id(),
                 tab->web_contents()->GetClosedByUserGesture());
       RecordSessionUpdateHistogramData(type, &last_updated_tab_closed_time_);
       break;
     }
 
     case content::NOTIFICATION_NAV_LIST_PRUNED: {
-      TabContentsWrapper* tab =
-          TabContentsWrapper::GetCurrentWrapperForContents(
-              content::Source<content::NavigationController>(
-                  source).ptr()->GetWebContents());
+      TabContents* tab = TabContents::FromWebContents(
+          content::Source<content::NavigationController>(source).ptr()->
+              GetWebContents());
       if (!tab || tab->profile() != profile())
         return;
       content::Details<content::PrunedDetails> pruned_details(details);
       if (pruned_details->from_front) {
         TabNavigationPathPrunedFromFront(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             pruned_details->count);
       } else {
         TabNavigationPathPrunedFromBack(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->web_contents()->GetController().GetEntryCount());
       }
       RecordSessionUpdateHistogramData(content::NOTIFICATION_NAV_LIST_PRUNED,
           &last_updated_nav_list_pruned_time_);
       break;
     }
 
     case content::NOTIFICATION_NAV_ENTRY_CHANGED: {
-      TabContentsWrapper* tab =
-          TabContentsWrapper::GetCurrentWrapperForContents(
-              content::Source<content::NavigationController>(
-                  source).ptr()->GetWebContents());
+      TabContents* tab = TabContents::FromWebContents(
+          content::Source<content::NavigationController>(source).ptr()->
+              GetWebContents());
       if (!tab || tab->profile() != profile())
         return;
       content::Details<content::EntryChangedDetails> changed(details);
       UpdateTabNavigation(
           tab->restore_tab_helper()->window_id(),
           tab->restore_tab_helper()->session_id(),
           changed->index, *changed->changed_entry);
       break;
     }
 
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
-      TabContentsWrapper* tab =
-          TabContentsWrapper::GetCurrentWrapperForContents(
-              content::Source<content::NavigationController>(
-                  source).ptr()->GetWebContents());
+      TabContents* tab = TabContents::FromWebContents(
+          content::Source<content::NavigationController>(source).ptr()->
+              GetWebContents());
       if (!tab || tab->profile() != profile())
         return;
       int current_entry_index =
           tab->web_contents()->GetController().GetCurrentEntryIndex();
       SetSelectedNavigationIndex(tab->restore_tab_helper()->window_id(),
                                  tab->restore_tab_helper()->session_id(),
                                  current_entry_index);
       UpdateTabNavigation(
           tab->restore_tab_helper()->window_id(),
           tab->restore_tab_helper()->session_id(),
@@ skipping 570 matching lines @@
       default:
         VLOG(1) << "Failed reading an unknown command " << command->id();
         return true;
     }
   }
   return true;
 }
 
 void SessionService::BuildCommandsForTab(
     const SessionID& window_id,
-    TabContentsWrapper* tab,
+    TabContents* tab,
     int index_in_window,
     bool is_pinned,
     std::vector<SessionCommand*>* commands,
     IdToRange* tab_to_available_range) {
   DCHECK(tab && commands && window_id.id());
   const SessionID& session_id(tab->restore_tab_helper()->session_id());
   commands->push_back(CreateSetTabWindowCommand(window_id, session_id));
 
   const int current_index =
       tab->web_contents()->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();
   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));
   }
 
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab->web_contents());
-  if (wrapper->extension_tab_helper()->extension_app()) {
+  if (tab->extension_tab_helper()->extension_app()) {
     commands->push_back(
         CreateSetTabExtensionAppIDCommand(
             kCommandSetExtensionAppID, session_id.id(),
-            wrapper->extension_tab_helper()->extension_app()->id()));
+            tab->extension_tab_helper()->extension_app()->id()));
   }
 
   const std::string& ua_override = tab->web_contents()->GetUserAgentOverride();
   if (!ua_override.empty()) {
     commands->push_back(
         CreateSetTabUserAgentOverrideCommand(
             kCommandSetTabUserAgentOverride, session_id.id(), ua_override));
   }
 
   for (int i = min_index; i < max_index; ++i) {
@@ skipping 40 matching lines @@
 
   if (!browser->app_name().empty()) {
     commands->push_back(CreateSetWindowAppNameCommand(
         kCommandSetWindowAppName,
         browser->session_id().id(),
         browser->app_name()));
   }
 
   bool added_to_windows_to_track = false;
   for (int i = 0; i < browser->tab_count(); ++i) {
-    TabContentsWrapper* tab = browser->GetTabContentsWrapperAt(i);
+    TabContents* tab = browser->GetTabContentsAt(i);
     DCHECK(tab);
     if (tab->profile() == profile() || profile() == NULL) {
       BuildCommandsForTab(browser->session_id(), tab, i,
                           browser->IsTabPinned(i),
                           commands, tab_to_available_range);
       if (windows_to_track && !added_to_windows_to_track) {
         windows_to_track->insert(browser->session_id().id());
         added_to_windows_to_track = true;
       }
     }
@@ skipping 328 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }