Take 2 at this. The only change between this and the first is to add the GetT...

chrome/browser/sessions/session_service.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #include "chrome/browser/sessions/session_service.h"
 
 #include <limits>
 
@@ skipping 101 matching lines @@
   SessionID::id_type tab_id;
   bool pinned_state;
 };
 
 }  // namespace
 
 // SessionService -------------------------------------------------------------
 
 SessionService::SessionService(Profile* profile)
     : BaseSessionService(SESSION_RESTORE, profile, FilePath()),
-      has_open_tabbed_browsers_(false),
+      has_open_trackable_browsers_(false),
       move_on_new_browser_(false) {
   Init();
 }
 
 SessionService::SessionService(const FilePath& save_path)
     : BaseSessionService(SESSION_RESTORE, NULL, save_path),
-      has_open_tabbed_browsers_(false),
+      has_open_trackable_browsers_(false),
       move_on_new_browser_(false) {
   Init();
 }
 
 SessionService::~SessionService() {
   Save();
 }
 
 void SessionService::ResetFromCurrentBrowsers() {
   ScheduleReset();
@@ skipping 69 matching lines @@
                   window_id.id()) != window_closing_ids_.end() ||
              !IsOnlyOneTabLeft()) {
     // Tab closure is the result of a window close (and it isn't the last
     // window), or closing a tab and there are other windows/tabs open. Mark the
     // tab as closed.
     ScheduleCommand(CreateTabClosedCommand(tab_id.id()));
   } else {
     // User closed the last tab in the last tabbed browser. Don't mark the
     // tab closed.
     pending_tab_close_ids_.insert(tab_id.id());
-    has_open_tabbed_browsers_ = false;
+    has_open_trackable_browsers_ = false;
   }
 }
 
 void SessionService::WindowClosing(const SessionID& window_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   // The window is about to close. If there are other tabbed browsers with the
   // same original profile commit the close immediately.
   //
   // NOTE: if the user chooses the exit menu item session service is destroyed
   // and this code isn't hit.
-  if (has_open_tabbed_browsers_) {
-    // Closing a window can never make has_open_tabbed_browsers_ go from false
-    // to true, so only update it if already true.
-    has_open_tabbed_browsers_ = HasOpenTabbedBrowsers(window_id);
+  if (has_open_trackable_browsers_) {
+    // Closing a window can never make has_open_trackable_browsers_ go from
+    // false to true, so only update it if already true.
+    has_open_trackable_browsers_ = HasOpenTrackableBrowsers(window_id);
   }
-  if (!has_open_tabbed_browsers_)
+  if (!has_open_trackable_browsers_)
     pending_window_close_ids_.insert(window_id.id());
   else
     window_closing_ids_.insert(window_id.id());
 }
 
 void SessionService::WindowClosed(const SessionID& window_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   windows_tracking_.erase(window_id.id());
 
   if (window_closing_ids_.find(window_id.id()) != window_closing_ids_.end()) {
     window_closing_ids_.erase(window_id.id());
     ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
   } else if (pending_window_close_ids_.find(window_id.id()) ==
              pending_window_close_ids_.end()) {
     // We'll hit this if user closed the last tab in a window.
-    has_open_tabbed_browsers_ = HasOpenTabbedBrowsers(window_id);
-    if (!has_open_tabbed_browsers_)
+    has_open_trackable_browsers_ = HasOpenTrackableBrowsers(window_id);
+    if (!has_open_trackable_browsers_)
       pending_window_close_ids_.insert(window_id.id());
     else
       ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
   }
 }
 
 void SessionService::SetWindowType(const SessionID& window_id,
                                    Browser::Type type) {
   if (!should_track_changes_for_browser_type(type))
     return;
 
   windows_tracking_.insert(window_id.id());
 
   // The user created a new tabbed browser with our profile. Commit any
   // pending closes.
   CommitPendingCloses();
 
-  has_open_tabbed_browsers_ = true;
+  has_open_trackable_browsers_ = true;
   move_on_new_browser_ = true;
 
   ScheduleCommand(CreateSetWindowTypeCommand(window_id, type));
 }
 
 void SessionService::TabNavigationPathPrunedFromBack(const SessionID& window_id,
                                                      const SessionID& tab_id,
                                                      int count) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
@@ skipping 117 matching lines @@
                              const NotificationDetails& details) {
   // All of our messages have the NavigationController as the source.
   switch (type.value) {
     case NotificationType::BROWSER_OPENED: {
       Browser* browser = Source<Browser>(source).ptr();
       if (browser->profile() != profile() ||
           !should_track_changes_for_browser_type(browser->type())) {
         return;
       }
 
-      if (!has_open_tabbed_browsers_ && !BrowserInit::InProcessStartup()) {
+      if (!has_open_trackable_browsers_ && !BrowserInit::InProcessStartup()) {
         // We're going from no tabbed browsers to a tabbed browser (and not in
         // process startup), restore the last session.
         if (move_on_new_browser_) {
           // Make the current session the last.
           MoveCurrentSessionToLastSession();
           move_on_new_browser_ = false;
         }
         SessionStartupPref pref = SessionStartupPref::GetStartupPref(profile());
         if (pref.type == SessionStartupPref::LAST) {
           SessionRestore::RestoreSession(
@@ skipping 589 matching lines @@
 void SessionService::ScheduleReset() {
   set_pending_reset(true);
   STLDeleteElements(&pending_commands());
   tab_to_available_range_.clear();
   windows_tracking_.clear();
   BuildCommandsFromBrowsers(&pending_commands(), &tab_to_available_range_,
                             &windows_tracking_);
   if (!windows_tracking_.empty()) {
     // We're lazily created on startup and won't get an initial batch of
     // SetWindowType messages. Set these here to make sure our state is correct.
-    has_open_tabbed_browsers_ = true;
+    has_open_trackable_browsers_ = true;
     move_on_new_browser_ = true;
   }
   StartSaveTimer();
 }
 
 bool SessionService::ReplacePendingCommand(SessionCommand* command) {
   // We only optimize page navigations, which can happen quite frequently and
   // are expensive. If necessary, other commands could be searched for as
   // well.
   if (command->id() != kCommandUpdateTabNavigation)
@@ skipping 68 matching lines @@
   pending_window_close_ids_.clear();
 }
 
 bool SessionService::IsOnlyOneTabLeft() {
   if (!profile()) {
     // We're testing, always return false.
     return false;
   }
 
   // NOTE: This uses the original profile so that closing the last non-off the
-  // record window while there are open off the record window resets state).
+  // record window while there are open off the record windows resets state).
   int window_count = 0;
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     const SessionID::id_type window_id = (*i)->session_id().id();
     if (should_track_changes_for_browser_type((*i)->type()) &&
         (*i)->profile()->GetOriginalProfile() == profile() &&
         window_closing_ids_.find(window_id) == window_closing_ids_.end()) {
       if (++window_count > 1)
         return false;
       // By the time this is invoked the tab has been removed. As such, we use
       // > 0 here rather than > 1.
       if ((*i)->tab_count() > 0)
         return false;
     }
   }
   return true;
 }
 
-bool SessionService::HasOpenTabbedBrowsers(const SessionID& window_id) {
+bool SessionService::HasOpenTrackableBrowsers(const SessionID& window_id) {
   if (!profile()) {
     // We're testing, always return false.
     return true;
   }
 
   // NOTE: This uses the original profile so that closing the last non-off the
   // record window while there are open off the record window resets state).
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     Browser* browser = *i;
     const SessionID::id_type browser_id = browser->session_id().id();
     if (browser_id != window_id.id() &&
         window_closing_ids_.find(browser_id) == window_closing_ids_.end() &&
         should_track_changes_for_browser_type(browser->type()) &&
         browser->profile()->GetOriginalProfile() == profile()) {
       return true;
     }
   }
   return false;
 }
 
 bool SessionService::ShouldTrackChangesToWindow(const SessionID& window_id) {
   return windows_tracking_.find(window_id.id()) != windows_tracking_.end();
 }