RestoreTabHelper > SessionTabHelper, move more session stuff into it.

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #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_tab_helper.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.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.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"
@@ skipping 402 matching lines @@
       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(TabContents* tab, bool pinned) {
-  if (!ShouldTrackChangesToWindow(tab->restore_tab_helper()->window_id()))
+  if (!ShouldTrackChangesToWindow(tab->session_tab_helper()->window_id()))
     return;
 
-  BuildCommandsForTab(tab->restore_tab_helper()->window_id(), tab, -1,
+  BuildCommandsForTab(tab->session_tab_helper()->window_id(), tab, -1,
                       pinned, &pending_commands(), NULL);
   StartSaveTimer();
 }
 
 void SessionService::SetSelectedNavigationIndex(const SessionID& window_id,
                                                 const SessionID& tab_id,
                                                 int index) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
@@ skipping 136 matching lines @@
       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: {
       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());
+      SetTabWindow(tab->session_tab_helper()->window_id(),
+                   tab->session_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->session_tab_helper()->window_id(),
+            tab->session_tab_helper()->session_id(),
             tab->extension_tab_helper()->extension_app()->id());
       }
 
       // Record the association between the SessionStorageNamespace and the
       // tab.
       //
       // TODO(ajwong): This should be processing the whole map rather than
       // just the default. This in particular will not work for tabs with only
       // isolated apps which won't have a default partition.
       content::SessionStorageNamespace* session_storage_namespace =
           tab->web_contents()->GetController().
               GetDefaultSessionStorageNamespace();
       ScheduleCommand(CreateSessionStorageAssociatedCommand(
-          tab->restore_tab_helper()->session_id(),
+          tab->session_tab_helper()->session_id(),
           session_storage_namespace->persistent_id()));
       session_storage_namespace->SetShouldPersist(true);
       break;
     }
 
     case chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
       TabContents* tab = content::Source<TabContents>(source).ptr();
       if (!tab || tab->profile() != profile())
         return;
       // Allow the associated sessionStorage to get deleted; it won't be needed
       // in the session restore.
       content::SessionStorageNamespace* session_storage_namespace =
           tab->web_contents()->GetController().
               GetDefaultSessionStorageNamespace();
       session_storage_namespace->SetShouldPersist(false);
-      TabClosed(tab->restore_tab_helper()->window_id(),
-                tab->restore_tab_helper()->session_id(),
+      TabClosed(tab->session_tab_helper()->window_id(),
+                tab->session_tab_helper()->session_id(),
                 tab->web_contents()->GetClosedByUserGesture());
       RecordSessionUpdateHistogramData(type, &last_updated_tab_closed_time_);
       break;
     }
 
     case content::NOTIFICATION_NAV_LIST_PRUNED: {
       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(),
+            tab->session_tab_helper()->window_id(),
+            tab->session_tab_helper()->session_id(),
             pruned_details->count);
       } else {
         TabNavigationPathPrunedFromBack(
-            tab->restore_tab_helper()->window_id(),
-            tab->restore_tab_helper()->session_id(),
+            tab->session_tab_helper()->window_id(),
+            tab->session_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: {
       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(),
+          tab->session_tab_helper()->window_id(),
+          tab->session_tab_helper()->session_id(),
           changed->index, *changed->changed_entry);
       break;
     }
 
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       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(),
+      SetSelectedNavigationIndex(tab->session_tab_helper()->window_id(),
+                                 tab->session_tab_helper()->session_id(),
                                  current_entry_index);
       UpdateTabNavigation(
-          tab->restore_tab_helper()->window_id(),
-          tab->restore_tab_helper()->session_id(),
+          tab->session_tab_helper()->window_id(),
+          tab->session_tab_helper()->session_id(),
           current_entry_index,
           *tab->web_contents()->GetController().GetEntryAtIndex(
               current_entry_index));
       content::Details<content::LoadCommittedDetails> changed(details);
       if (changed->type == content::NAVIGATION_TYPE_NEW_PAGE ||
         changed->type == content::NAVIGATION_TYPE_EXISTING_PAGE) {
         RecordSessionUpdateHistogramData(
             content::NOTIFICATION_NAV_ENTRY_COMMITTED,
             &last_updated_nav_entry_commit_time_);
       }
       break;
     }
 
     case chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED: {
       extensions::TabHelper* extension_tab_helper =
           content::Source<extensions::TabHelper>(source).ptr();
       if (extension_tab_helper->tab_contents()->profile() != profile())
         return;
       if (extension_tab_helper->extension_app()) {
-        RestoreTabHelper* helper =
-            extension_tab_helper->tab_contents()->restore_tab_helper();
+        SessionTabHelper* helper =
+            extension_tab_helper->tab_contents()->session_tab_helper();
         SetTabExtensionAppID(helper->window_id(),
                              helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
@@ skipping 555 matching lines @@
 }
 
 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) {
   DCHECK(tab && commands && window_id.id());
-  const SessionID& session_id(tab->restore_tab_helper()->session_id());
+  const SessionID& session_id(tab->session_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 =
@@ skipping 37 matching lines @@
 
   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();
   ScheduleCommand(CreateSessionStorageAssociatedCommand(
-      tab->restore_tab_helper()->session_id(),
+      tab->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) {
   DCHECK(browser && commands);
   DCHECK(browser->session_id().id());
@@ skipping 363 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);
   }
 }