Home | History | Annotate | Download | only in sessions 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sessions/session_service.h"
      6 
      7 #include <algorithm>
      8 #include <set>
      9 #include <utility>
     10 #include <vector>
     11 
     12 #include "base/bind.h"
     13 #include "base/bind_helpers.h"
     14 #include "base/command_line.h"
     15 #include "base/message_loop/message_loop.h"
     16 #include "base/metrics/histogram.h"
     17 #include "base/pickle.h"
     18 #include "base/threading/thread.h"
     19 #include "chrome/browser/background/background_mode_manager.h"
     20 #include "chrome/browser/browser_process.h"
     21 #include "chrome/browser/chrome_notification_types.h"
     22 #include "chrome/browser/defaults.h"
     23 #include "chrome/browser/extensions/tab_helper.h"
     24 #include "chrome/browser/prefs/session_startup_pref.h"
     25 #include "chrome/browser/profiles/profile.h"
     26 #include "chrome/browser/profiles/profile_manager.h"
     27 #include "chrome/browser/sessions/session_backend.h"
     28 #include "chrome/browser/sessions/session_command.h"
     29 #include "chrome/browser/sessions/session_data_deleter.h"
     30 #include "chrome/browser/sessions/session_restore.h"
     31 #include "chrome/browser/sessions/session_tab_helper.h"
     32 #include "chrome/browser/sessions/session_types.h"
     33 #include "chrome/browser/ui/browser_iterator.h"
     34 #include "chrome/browser/ui/browser_list.h"
     35 #include "chrome/browser/ui/browser_tabstrip.h"
     36 #include "chrome/browser/ui/browser_window.h"
     37 #include "chrome/browser/ui/host_desktop.h"
     38 #include "chrome/browser/ui/startup/startup_browser_creator.h"
     39 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     40 #include "components/startup_metric_utils/startup_metric_utils.h"
     41 #include "content/public/browser/navigation_details.h"
     42 #include "content/public/browser/navigation_entry.h"
     43 #include "content/public/browser/notification_details.h"
     44 #include "content/public/browser/notification_service.h"
     45 #include "content/public/browser/session_storage_namespace.h"
     46 #include "content/public/browser/web_contents.h"
     47 #include "extensions/common/extension.h"
     48 
     49 #if defined(OS_MACOSX)
     50 #include "chrome/browser/app_controller_mac.h"
     51 #endif
     52 
     53 using base::Time;
     54 using content::NavigationEntry;
     55 using content::WebContents;
     56 using sessions::SerializedNavigationEntry;
     57 
     58 // Identifier for commands written to file.
     59 static const SessionCommand::id_type kCommandSetTabWindow = 0;
     60 // OBSOLETE Superseded by kCommandSetWindowBounds3.
     61 // static const SessionCommand::id_type kCommandSetWindowBounds = 1;
     62 static const SessionCommand::id_type kCommandSetTabIndexInWindow = 2;
     63 // Original kCommandTabClosed/kCommandWindowClosed. See comment in
     64 // MigrateClosedPayload for details on why they were replaced.
     65 static const SessionCommand::id_type kCommandTabClosedObsolete = 3;
     66 static const SessionCommand::id_type kCommandWindowClosedObsolete = 4;
     67 static const SessionCommand::id_type
     68     kCommandTabNavigationPathPrunedFromBack = 5;
     69 static const SessionCommand::id_type kCommandUpdateTabNavigation = 6;
     70 static const SessionCommand::id_type kCommandSetSelectedNavigationIndex = 7;
     71 static const SessionCommand::id_type kCommandSetSelectedTabInIndex = 8;
     72 static const SessionCommand::id_type kCommandSetWindowType = 9;
     73 // OBSOLETE Superseded by kCommandSetWindowBounds3. Except for data migration.
     74 // static const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
     75 static const SessionCommand::id_type
     76     kCommandTabNavigationPathPrunedFromFront = 11;
     77 static const SessionCommand::id_type kCommandSetPinnedState = 12;
     78 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
     79 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
     80 static const SessionCommand::id_type kCommandSetWindowAppName = 15;
     81 static const SessionCommand::id_type kCommandTabClosed = 16;
     82 static const SessionCommand::id_type kCommandWindowClosed = 17;
     83 static const SessionCommand::id_type kCommandSetTabUserAgentOverride = 18;
     84 static const SessionCommand::id_type kCommandSessionStorageAssociated = 19;
     85 static const SessionCommand::id_type kCommandSetActiveWindow = 20;
     86 
     87 // Every kWritesPerReset commands triggers recreating the file.
     88 static const int kWritesPerReset = 250;
     89 
     90 namespace {
     91 
     92 // Various payload structures.
     93 struct ClosedPayload {
     94   SessionID::id_type id;
     95   int64 close_time;
     96 };
     97 
     98 struct WindowBoundsPayload2 {
     99   SessionID::id_type window_id;
    100   int32 x;
    101   int32 y;
    102   int32 w;
    103   int32 h;
    104   bool is_maximized;
    105 };
    106 
    107 struct WindowBoundsPayload3 {
    108   SessionID::id_type window_id;
    109   int32 x;
    110   int32 y;
    111   int32 w;
    112   int32 h;
    113   int32 show_state;
    114 };
    115 
    116 typedef SessionID::id_type ActiveWindowPayload;
    117 
    118 struct IDAndIndexPayload {
    119   SessionID::id_type id;
    120   int32 index;
    121 };
    122 
    123 typedef IDAndIndexPayload TabIndexInWindowPayload;
    124 
    125 typedef IDAndIndexPayload TabNavigationPathPrunedFromBackPayload;
    126 
    127 typedef IDAndIndexPayload SelectedNavigationIndexPayload;
    128 
    129 typedef IDAndIndexPayload SelectedTabInIndexPayload;
    130 
    131 typedef IDAndIndexPayload WindowTypePayload;
    132 
    133 typedef IDAndIndexPayload TabNavigationPathPrunedFromFrontPayload;
    134 
    135 struct PinnedStatePayload {
    136   SessionID::id_type tab_id;
    137   bool pinned_state;
    138 };
    139 
    140 // Returns the show state to store to disk based |state|.
    141 ui::WindowShowState AdjustShowState(ui::WindowShowState state) {
    142   switch (state) {
    143     case ui::SHOW_STATE_NORMAL:
    144     case ui::SHOW_STATE_MINIMIZED:
    145     case ui::SHOW_STATE_MAXIMIZED:
    146     case ui::SHOW_STATE_FULLSCREEN:
    147     case ui::SHOW_STATE_DETACHED:
    148       return state;
    149 
    150     case ui::SHOW_STATE_DEFAULT:
    151     case ui::SHOW_STATE_INACTIVE:
    152     case ui::SHOW_STATE_END:
    153       return ui::SHOW_STATE_NORMAL;
    154   }
    155   return ui::SHOW_STATE_NORMAL;
    156 }
    157 
    158 // Migrates a |ClosedPayload|, returning true on success (migration was
    159 // necessary and happened), or false (migration was not necessary or was not
    160 // successful).
    161 bool MigrateClosedPayload(const SessionCommand& command,
    162                           ClosedPayload* payload) {
    163 #if defined(OS_CHROMEOS)
    164   // Pre M17 versions of chromeos were 32bit. Post M17 is 64 bit. Apparently the
    165   // 32 bit versions of chrome on pre M17 resulted in a sizeof 12 for the
    166   // ClosedPayload, where as post M17 64-bit gives a sizeof 16 (presumably the
    167   // struct is padded).
    168   if ((command.id() == kCommandWindowClosedObsolete ||
    169        command.id() == kCommandTabClosedObsolete) &&
    170       command.size() == 12 && sizeof(payload->id) == 4 &&
    171       sizeof(payload->close_time) == 8) {
    172     memcpy(&payload->id, command.contents(), 4);
    173     memcpy(&payload->close_time, command.contents() + 4, 8);
    174     return true;
    175   } else {
    176     return false;
    177   }
    178 #else
    179   return false;
    180 #endif
    181 }
    182 
    183 }  // namespace
    184 
    185 // SessionService -------------------------------------------------------------
    186 
    187 SessionService::SessionService(Profile* profile)
    188     : BaseSessionService(SESSION_RESTORE, profile, base::FilePath()),
    189       has_open_trackable_browsers_(false),
    190       move_on_new_browser_(false),
    191       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
    192       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
    193       save_delay_in_hrs_(base::TimeDelta::FromHours(8)),
    194       force_browser_not_alive_with_no_windows_(false) {
    195   Init();
    196 }
    197 
    198 SessionService::SessionService(const base::FilePath& save_path)
    199     : BaseSessionService(SESSION_RESTORE, NULL, save_path),
    200       has_open_trackable_browsers_(false),
    201       move_on_new_browser_(false),
    202       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
    203       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
    204       save_delay_in_hrs_(base::TimeDelta::FromHours(8)),
    205       force_browser_not_alive_with_no_windows_(false)  {
    206   Init();
    207 }
    208 
    209 SessionService::~SessionService() {
    210   // The BrowserList should outlive the SessionService since it's static and
    211   // the SessionService is a KeyedService.
    212   BrowserList::RemoveObserver(this);
    213   Save();
    214 }
    215 
    216 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open) {
    217   return RestoreIfNecessary(urls_to_open, NULL);
    218 }
    219 
    220 void SessionService::ResetFromCurrentBrowsers() {
    221   ScheduleReset();
    222 }
    223 
    224 void SessionService::MoveCurrentSessionToLastSession() {
    225   pending_tab_close_ids_.clear();
    226   window_closing_ids_.clear();
    227   pending_window_close_ids_.clear();
    228 
    229   Save();
    230 
    231   RunTaskOnBackendThread(
    232       FROM_HERE, base::Bind(&SessionBackend::MoveCurrentSessionToLastSession,
    233                             backend()));
    234 }
    235 
    236 void SessionService::SetTabWindow(const SessionID& window_id,
    237                                   const SessionID& tab_id) {
    238   if (!ShouldTrackChangesToWindow(window_id))
    239     return;
    240 
    241   ScheduleCommand(CreateSetTabWindowCommand(window_id, tab_id));
    242 }
    243 
    244 void SessionService::SetWindowBounds(const SessionID& window_id,
    245                                      const gfx::Rect& bounds,
    246                                      ui::WindowShowState show_state) {
    247   if (!ShouldTrackChangesToWindow(window_id))
    248     return;
    249 
    250   ScheduleCommand(CreateSetWindowBoundsCommand(window_id, bounds, show_state));
    251 }
    252 
    253 void SessionService::SetTabIndexInWindow(const SessionID& window_id,
    254                                          const SessionID& tab_id,
    255                                          int new_index) {
    256   if (!ShouldTrackChangesToWindow(window_id))
    257     return;
    258 
    259   ScheduleCommand(CreateSetTabIndexInWindowCommand(tab_id, new_index));
    260 }
    261 
    262 void SessionService::SetPinnedState(const SessionID& window_id,
    263                                     const SessionID& tab_id,
    264                                     bool is_pinned) {
    265   if (!ShouldTrackChangesToWindow(window_id))
    266     return;
    267 
    268   ScheduleCommand(CreatePinnedStateCommand(tab_id, is_pinned));
    269 }
    270 
    271 void SessionService::TabClosed(const SessionID& window_id,
    272                                const SessionID& tab_id,
    273                                bool closed_by_user_gesture) {
    274   if (!tab_id.id())
    275     return;  // Hapens when the tab is replaced.
    276 
    277   if (!ShouldTrackChangesToWindow(window_id))
    278     return;
    279 
    280   IdToRange::iterator i = tab_to_available_range_.find(tab_id.id());
    281   if (i != tab_to_available_range_.end())
    282     tab_to_available_range_.erase(i);
    283 
    284   if (find(pending_window_close_ids_.begin(), pending_window_close_ids_.end(),
    285            window_id.id()) != pending_window_close_ids_.end()) {
    286     // Tab is in last window. Don't commit it immediately, instead add it to the
    287     // list of tabs to close. If the user creates another window, the close is
    288     // committed.
    289     pending_tab_close_ids_.insert(tab_id.id());
    290   } else if (find(window_closing_ids_.begin(), window_closing_ids_.end(),
    291                   window_id.id()) != window_closing_ids_.end() ||
    292              !IsOnlyOneTabLeft() ||
    293              closed_by_user_gesture) {
    294     // Close is the result of one of the following:
    295     // . window close (and it isn't the last window).
    296     // . closing a tab and there are other windows/tabs open.
    297     // . closed by a user gesture.
    298     // In all cases we need to mark the tab as explicitly closed.
    299     ScheduleCommand(CreateTabClosedCommand(tab_id.id()));
    300   } else {
    301     // User closed the last tab in the last tabbed browser. Don't mark the
    302     // tab closed.
    303     pending_tab_close_ids_.insert(tab_id.id());
    304     has_open_trackable_browsers_ = false;
    305   }
    306 }
    307 
    308 void SessionService::WindowOpened(Browser* browser) {
    309   if (!ShouldTrackBrowser(browser))
    310     return;
    311 
    312   AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
    313   RestoreIfNecessary(std::vector<GURL>(), browser);
    314   SetWindowType(browser->session_id(), browser->type(), app_type);
    315   SetWindowAppName(browser->session_id(), browser->app_name());
    316 }
    317 
    318 void SessionService::WindowClosing(const SessionID& window_id) {
    319   if (!ShouldTrackChangesToWindow(window_id))
    320     return;
    321 
    322   // The window is about to close. If there are other tabbed browsers with the
    323   // same original profile commit the close immediately.
    324   //
    325   // NOTE: if the user chooses the exit menu item session service is destroyed
    326   // and this code isn't hit.
    327   if (has_open_trackable_browsers_) {
    328     // Closing a window can never make has_open_trackable_browsers_ go from
    329     // false to true, so only update it if already true.
    330     has_open_trackable_browsers_ = HasOpenTrackableBrowsers(window_id);
    331   }
    332   bool use_pending_close = !has_open_trackable_browsers_;
    333   if (!use_pending_close) {
    334     // Somewhat outside of "normal behavior" is profile locking.  In this case
    335     // (when IsSiginRequired has already been set True), we're closing all
    336     // browser windows in turn but want them all to be restored when the user
    337     // unlocks.  To accomplish this, we do a "pending close" on all windows
    338     // instead of just the last one (which has no open_trackable_browsers).
    339     // http://crbug.com/356818
    340     //
    341     // Some editions (like iOS) don't have a profile_manager and some tests
    342     // don't supply one so be lenient.
    343     if (g_browser_process) {
    344       ProfileManager* profile_manager = g_browser_process->profile_manager();
    345       if (profile_manager) {
    346         ProfileInfoCache& profile_info =
    347             profile_manager->GetProfileInfoCache();
    348         size_t profile_index = profile_info.GetIndexOfProfileWithPath(
    349             profile()->GetPath());
    350         use_pending_close = profile_index != std::string::npos &&
    351             profile_info.ProfileIsSigninRequiredAtIndex(profile_index);
    352       }
    353     }
    354   }
    355   if (use_pending_close)
    356     pending_window_close_ids_.insert(window_id.id());
    357   else
    358     window_closing_ids_.insert(window_id.id());
    359 }
    360 
    361 void SessionService::WindowClosed(const SessionID& window_id) {
    362   if (!ShouldTrackChangesToWindow(window_id)) {
    363     // The last window may be one that is not tracked.
    364     MaybeDeleteSessionOnlyData();
    365     return;
    366   }
    367 
    368   windows_tracking_.erase(window_id.id());
    369 
    370   if (window_closing_ids_.find(window_id.id()) != window_closing_ids_.end()) {
    371     window_closing_ids_.erase(window_id.id());
    372     ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
    373   } else if (pending_window_close_ids_.find(window_id.id()) ==
    374              pending_window_close_ids_.end()) {
    375     // We'll hit this if user closed the last tab in a window.
    376     has_open_trackable_browsers_ = HasOpenTrackableBrowsers(window_id);
    377     if (!has_open_trackable_browsers_)
    378       pending_window_close_ids_.insert(window_id.id());
    379     else
    380       ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
    381   }
    382   MaybeDeleteSessionOnlyData();
    383 }
    384 
    385 void SessionService::SetWindowType(const SessionID& window_id,
    386                                    Browser::Type type,
    387                                    AppType app_type) {
    388   if (!should_track_changes_for_browser_type(type, app_type))
    389     return;
    390 
    391   windows_tracking_.insert(window_id.id());
    392 
    393   // The user created a new tabbed browser with our profile. Commit any
    394   // pending closes.
    395   CommitPendingCloses();
    396 
    397   has_open_trackable_browsers_ = true;
    398   move_on_new_browser_ = true;
    399 
    400   ScheduleCommand(
    401       CreateSetWindowTypeCommand(window_id, WindowTypeForBrowserType(type)));
    402 }
    403 
    404 void SessionService::SetWindowAppName(
    405     const SessionID& window_id,
    406     const std::string& app_name) {
    407   if (!ShouldTrackChangesToWindow(window_id))
    408     return;
    409 
    410   ScheduleCommand(CreateSetTabExtensionAppIDCommand(
    411                       kCommandSetWindowAppName,
    412                       window_id.id(),
    413                       app_name));
    414 }
    415 
    416 void SessionService::TabNavigationPathPrunedFromBack(const SessionID& window_id,
    417                                                      const SessionID& tab_id,
    418                                                      int count) {
    419   if (!ShouldTrackChangesToWindow(window_id))
    420     return;
    421 
    422   TabNavigationPathPrunedFromBackPayload payload = { 0 };
    423   payload.id = tab_id.id();
    424   payload.index = count;
    425   SessionCommand* command =
    426       new SessionCommand(kCommandTabNavigationPathPrunedFromBack,
    427                          sizeof(payload));
    428   memcpy(command->contents(), &payload, sizeof(payload));
    429   ScheduleCommand(command);
    430 }
    431 
    432 void SessionService::TabNavigationPathPrunedFromFront(
    433     const SessionID& window_id,
    434     const SessionID& tab_id,
    435     int count) {
    436   if (!ShouldTrackChangesToWindow(window_id))
    437     return;
    438 
    439   // Update the range of indices.
    440   if (tab_to_available_range_.find(tab_id.id()) !=
    441       tab_to_available_range_.end()) {
    442     std::pair<int, int>& range = tab_to_available_range_[tab_id.id()];
    443     range.first = std::max(0, range.first - count);
    444     range.second = std::max(0, range.second - count);
    445   }
    446 
    447   TabNavigationPathPrunedFromFrontPayload payload = { 0 };
    448   payload.id = tab_id.id();
    449   payload.index = count;
    450   SessionCommand* command =
    451       new SessionCommand(kCommandTabNavigationPathPrunedFromFront,
    452                          sizeof(payload));
    453   memcpy(command->contents(), &payload, sizeof(payload));
    454   ScheduleCommand(command);
    455 }
    456 
    457 void SessionService::UpdateTabNavigation(
    458     const SessionID& window_id,
    459     const SessionID& tab_id,
    460     const SerializedNavigationEntry& navigation) {
    461   if (!ShouldTrackEntry(navigation.virtual_url()) ||
    462       !ShouldTrackChangesToWindow(window_id)) {
    463     return;
    464   }
    465 
    466   if (tab_to_available_range_.find(tab_id.id()) !=
    467       tab_to_available_range_.end()) {
    468     std::pair<int, int>& range = tab_to_available_range_[tab_id.id()];
    469     range.first = std::min(navigation.index(), range.first);
    470     range.second = std::max(navigation.index(), range.second);
    471   }
    472   ScheduleCommand(CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
    473                                                    tab_id.id(), navigation));
    474 }
    475 
    476 void SessionService::TabRestored(WebContents* tab, bool pinned) {
    477   SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
    478   if (!ShouldTrackChangesToWindow(session_tab_helper->window_id()))
    479     return;
    480 
    481   BuildCommandsForTab(session_tab_helper->window_id(), tab, -1,
    482                       pinned, &pending_commands(), NULL);
    483   StartSaveTimer();
    484 }
    485 
    486 void SessionService::SetSelectedNavigationIndex(const SessionID& window_id,
    487                                                 const SessionID& tab_id,
    488                                                 int index) {
    489   if (!ShouldTrackChangesToWindow(window_id))
    490     return;
    491 
    492   if (tab_to_available_range_.find(tab_id.id()) !=
    493       tab_to_available_range_.end()) {
    494     if (index < tab_to_available_range_[tab_id.id()].first ||
    495         index > tab_to_available_range_[tab_id.id()].second) {
    496       // The new index is outside the range of what we've archived, schedule
    497       // a reset.
    498       ResetFromCurrentBrowsers();
    499       return;
    500     }
    501   }
    502   ScheduleCommand(CreateSetSelectedNavigationIndexCommand(tab_id, index));
    503 }
    504 
    505 void SessionService::SetSelectedTabInWindow(const SessionID& window_id,
    506                                             int index) {
    507   if (!ShouldTrackChangesToWindow(window_id))
    508     return;
    509 
    510   ScheduleCommand(CreateSetSelectedTabInWindow(window_id, index));
    511 }
    512 
    513 void SessionService::SetTabUserAgentOverride(
    514     const SessionID& window_id,
    515     const SessionID& tab_id,
    516     const std::string& user_agent_override) {
    517   if (!ShouldTrackChangesToWindow(window_id))
    518     return;
    519 
    520   ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
    521       kCommandSetTabUserAgentOverride, tab_id.id(), user_agent_override));
    522 }
    523 
    524 base::CancelableTaskTracker::TaskId SessionService::GetLastSession(
    525     const SessionCallback& callback,
    526     base::CancelableTaskTracker* tracker) {
    527   // OnGotSessionCommands maps the SessionCommands to browser state, then run
    528   // the callback.
    529   return ScheduleGetLastSessionCommands(
    530       base::Bind(&SessionService::OnGotSessionCommands,
    531                  base::Unretained(this), callback),
    532       tracker);
    533 }
    534 
    535 void SessionService::Save() {
    536   bool had_commands = !pending_commands().empty();
    537   BaseSessionService::Save();
    538   if (had_commands) {
    539     RecordSessionUpdateHistogramData(chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
    540                                      &last_updated_save_time_);
    541     content::NotificationService::current()->Notify(
    542         chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
    543         content::Source<Profile>(profile()),
    544         content::NotificationService::NoDetails());
    545   }
    546 }
    547 
    548 void SessionService::Init() {
    549   // Register for the notifications we're interested in.
    550   registrar_.Add(this, content::NOTIFICATION_NAV_LIST_PRUNED,
    551                  content::NotificationService::AllSources());
    552   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
    553                  content::NotificationService::AllSources());
    554   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
    555                  content::NotificationService::AllSources());
    556   registrar_.Add(
    557       this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
    558       content::NotificationService::AllSources());
    559 
    560   BrowserList::AddObserver(this);
    561 }
    562 
    563 bool SessionService::processed_any_commands() {
    564   return backend()->inited() || !pending_commands().empty();
    565 }
    566 
    567 bool SessionService::ShouldNewWindowStartSession() {
    568   // ChromeOS and OSX have different ideas of application lifetime than
    569   // the other platforms.
    570   // On ChromeOS opening a new window should never start a new session.
    571 #if defined(OS_CHROMEOS)
    572   if (!force_browser_not_alive_with_no_windows_)
    573     return false;
    574 #endif
    575   if (!has_open_trackable_browsers_ &&
    576       !StartupBrowserCreator::InSynchronousProfileLaunch() &&
    577       !SessionRestore::IsRestoring(profile())
    578 #if defined(OS_MACOSX)
    579       // On OSX, a new window should not start a new session if it was opened
    580       // from the dock or the menubar.
    581       && !app_controller_mac::IsOpeningNewWindow()
    582 #endif  // OS_MACOSX
    583       ) {
    584     return true;
    585   }
    586   return false;
    587 }
    588 
    589 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open,
    590                                         Browser* browser) {
    591   if (ShouldNewWindowStartSession()) {
    592     // We're going from no tabbed browsers to a tabbed browser (and not in
    593     // process startup), restore the last session.
    594     if (move_on_new_browser_) {
    595       // Make the current session the last.
    596       MoveCurrentSessionToLastSession();
    597       move_on_new_browser_ = false;
    598     }
    599     SessionStartupPref pref = StartupBrowserCreator::GetSessionStartupPref(
    600         *CommandLine::ForCurrentProcess(), profile());
    601     if (pref.type == SessionStartupPref::LAST) {
    602       SessionRestore::RestoreSession(
    603           profile(), browser,
    604           browser ? browser->host_desktop_type() : chrome::GetActiveDesktop(),
    605           browser ? 0 : SessionRestore::ALWAYS_CREATE_TABBED_BROWSER,
    606           urls_to_open);
    607       return true;
    608     }
    609   }
    610   return false;
    611 }
    612 
    613 void SessionService::Observe(int type,
    614                              const content::NotificationSource& source,
    615                              const content::NotificationDetails& details) {
    616   // All of our messages have the NavigationController as the source.
    617   switch (type) {
    618     case content::NOTIFICATION_NAV_LIST_PRUNED: {
    619       WebContents* web_contents =
    620           content::Source<content::NavigationController>(source).ptr()->
    621               GetWebContents();
    622       SessionTabHelper* session_tab_helper =
    623           SessionTabHelper::FromWebContents(web_contents);
    624       if (!session_tab_helper || web_contents->GetBrowserContext() != profile())
    625         return;
    626       content::Details<content::PrunedDetails> pruned_details(details);
    627       if (pruned_details->from_front) {
    628         TabNavigationPathPrunedFromFront(
    629             session_tab_helper->window_id(),
    630             session_tab_helper->session_id(),
    631             pruned_details->count);
    632       } else {
    633         TabNavigationPathPrunedFromBack(
    634             session_tab_helper->window_id(),
    635             session_tab_helper->session_id(),
    636             web_contents->GetController().GetEntryCount());
    637       }
    638       RecordSessionUpdateHistogramData(type,
    639                                        &last_updated_nav_list_pruned_time_);
    640       break;
    641     }
    642 
    643     case content::NOTIFICATION_NAV_ENTRY_CHANGED: {
    644       WebContents* web_contents =
    645           content::Source<content::NavigationController>(source).ptr()->
    646               GetWebContents();
    647       SessionTabHelper* session_tab_helper =
    648           SessionTabHelper::FromWebContents(web_contents);
    649       if (!session_tab_helper || web_contents->GetBrowserContext() != profile())
    650         return;
    651       content::Details<content::EntryChangedDetails> changed(details);
    652       const SerializedNavigationEntry navigation =
    653           SerializedNavigationEntry::FromNavigationEntry(
    654               changed->index, *changed->changed_entry);
    655       UpdateTabNavigation(session_tab_helper->window_id(),
    656                           session_tab_helper->session_id(),
    657                           navigation);
    658       break;
    659     }
    660 
    661     case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
    662       WebContents* web_contents =
    663           content::Source<content::NavigationController>(source).ptr()->
    664               GetWebContents();
    665       SessionTabHelper* session_tab_helper =
    666           SessionTabHelper::FromWebContents(web_contents);
    667       if (!session_tab_helper || web_contents->GetBrowserContext() != profile())
    668         return;
    669       int current_entry_index =
    670           web_contents->GetController().GetCurrentEntryIndex();
    671       SetSelectedNavigationIndex(
    672           session_tab_helper->window_id(),
    673           session_tab_helper->session_id(),
    674           current_entry_index);
    675       const SerializedNavigationEntry navigation =
    676           SerializedNavigationEntry::FromNavigationEntry(
    677               current_entry_index,
    678               *web_contents->GetController().GetEntryAtIndex(
    679                   current_entry_index));
    680       UpdateTabNavigation(
    681           session_tab_helper->window_id(),
    682           session_tab_helper->session_id(),
    683           navigation);
    684       content::Details<content::LoadCommittedDetails> changed(details);
    685       if (changed->type == content::NAVIGATION_TYPE_NEW_PAGE ||
    686         changed->type == content::NAVIGATION_TYPE_EXISTING_PAGE) {
    687         RecordSessionUpdateHistogramData(type,
    688                                          &last_updated_nav_entry_commit_time_);
    689       }
    690       break;
    691     }
    692 
    693     case chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED: {
    694       extensions::TabHelper* extension_tab_helper =
    695           content::Source<extensions::TabHelper>(source).ptr();
    696       if (extension_tab_helper->web_contents()->GetBrowserContext() !=
    697               profile()) {
    698         return;
    699       }
    700       if (extension_tab_helper->extension_app()) {
    701         SessionTabHelper* session_tab_helper =
    702             SessionTabHelper::FromWebContents(
    703                 extension_tab_helper->web_contents());
    704         SetTabExtensionAppID(session_tab_helper->window_id(),
    705                              session_tab_helper->session_id(),
    706                              extension_tab_helper->extension_app()->id());
    707       }
    708       break;
    709     }
    710 
    711     default:
    712       NOTREACHED();
    713   }
    714 }
    715 
    716 void SessionService::OnBrowserSetLastActive(Browser* browser) {
    717   if (ShouldTrackBrowser(browser))
    718     ScheduleCommand(CreateSetActiveWindowCommand(browser->session_id()));
    719 }
    720 
    721 void SessionService::SetTabExtensionAppID(
    722     const SessionID& window_id,
    723     const SessionID& tab_id,
    724     const std::string& extension_app_id) {
    725   if (!ShouldTrackChangesToWindow(window_id))
    726     return;
    727 
    728   ScheduleCommand(CreateSetTabExtensionAppIDCommand(kCommandSetExtensionAppID,
    729       tab_id.id(), extension_app_id));
    730 }
    731 
    732 SessionCommand* SessionService::CreateSetSelectedTabInWindow(
    733     const SessionID& window_id,
    734     int index) {
    735   SelectedTabInIndexPayload payload = { 0 };
    736   payload.id = window_id.id();
    737   payload.index = index;
    738   SessionCommand* command = new SessionCommand(kCommandSetSelectedTabInIndex,
    739                                  sizeof(payload));
    740   memcpy(command->contents(), &payload, sizeof(payload));
    741   return command;
    742 }
    743 
    744 SessionCommand* SessionService::CreateSetTabWindowCommand(
    745     const SessionID& window_id,
    746     const SessionID& tab_id) {
    747   SessionID::id_type payload[] = { window_id.id(), tab_id.id() };
    748   SessionCommand* command =
    749       new SessionCommand(kCommandSetTabWindow, sizeof(payload));
    750   memcpy(command->contents(), payload, sizeof(payload));
    751   return command;
    752 }
    753 
    754 SessionCommand* SessionService::CreateSetWindowBoundsCommand(
    755     const SessionID& window_id,
    756     const gfx::Rect& bounds,
    757     ui::WindowShowState show_state) {
    758   WindowBoundsPayload3 payload = { 0 };
    759   payload.window_id = window_id.id();
    760   payload.x = bounds.x();
    761   payload.y = bounds.y();
    762   payload.w = bounds.width();
    763   payload.h = bounds.height();
    764   payload.show_state = AdjustShowState(show_state);
    765   SessionCommand* command = new SessionCommand(kCommandSetWindowBounds3,
    766                                                sizeof(payload));
    767   memcpy(command->contents(), &payload, sizeof(payload));
    768   return command;
    769 }
    770 
    771 SessionCommand* SessionService::CreateSetTabIndexInWindowCommand(
    772     const SessionID& tab_id,
    773     int new_index) {
    774   TabIndexInWindowPayload payload = { 0 };
    775   payload.id = tab_id.id();
    776   payload.index = new_index;
    777   SessionCommand* command =
    778       new SessionCommand(kCommandSetTabIndexInWindow, sizeof(payload));
    779   memcpy(command->contents(), &payload, sizeof(payload));
    780   return command;
    781 }
    782 
    783 SessionCommand* SessionService::CreateTabClosedCommand(
    784     const SessionID::id_type tab_id) {
    785   ClosedPayload payload;
    786   // Because of what appears to be a compiler bug setting payload to {0} doesn't
    787   // set the padding to 0, resulting in Purify reporting an UMR when we write
    788   // the structure to disk. To avoid this we explicitly memset the struct.
    789   memset(&payload, 0, sizeof(payload));
    790   payload.id = tab_id;
    791   payload.close_time = Time::Now().ToInternalValue();
    792   SessionCommand* command =
    793       new SessionCommand(kCommandTabClosed, sizeof(payload));
    794   memcpy(command->contents(), &payload, sizeof(payload));
    795   return command;
    796 }
    797 
    798 SessionCommand* SessionService::CreateWindowClosedCommand(
    799     const SessionID::id_type window_id) {
    800   ClosedPayload payload;
    801   // See comment in CreateTabClosedCommand as to why we do this.
    802   memset(&payload, 0, sizeof(payload));
    803   payload.id = window_id;
    804   payload.close_time = Time::Now().ToInternalValue();
    805   SessionCommand* command =
    806       new SessionCommand(kCommandWindowClosed, sizeof(payload));
    807   memcpy(command->contents(), &payload, sizeof(payload));
    808   return command;
    809 }
    810 
    811 SessionCommand* SessionService::CreateSetSelectedNavigationIndexCommand(
    812     const SessionID& tab_id,
    813     int index) {
    814   SelectedNavigationIndexPayload payload = { 0 };
    815   payload.id = tab_id.id();
    816   payload.index = index;
    817   SessionCommand* command = new SessionCommand(
    818       kCommandSetSelectedNavigationIndex, sizeof(payload));
    819   memcpy(command->contents(), &payload, sizeof(payload));
    820   return command;
    821 }
    822 
    823 SessionCommand* SessionService::CreateSetWindowTypeCommand(
    824     const SessionID& window_id,
    825     WindowType type) {
    826   WindowTypePayload payload = { 0 };
    827   payload.id = window_id.id();
    828   payload.index = static_cast<int32>(type);
    829   SessionCommand* command = new SessionCommand(
    830       kCommandSetWindowType, sizeof(payload));
    831   memcpy(command->contents(), &payload, sizeof(payload));
    832   return command;
    833 }
    834 
    835 SessionCommand* SessionService::CreatePinnedStateCommand(
    836     const SessionID& tab_id,
    837     bool is_pinned) {
    838   PinnedStatePayload payload = { 0 };
    839   payload.tab_id = tab_id.id();
    840   payload.pinned_state = is_pinned;
    841   SessionCommand* command =
    842       new SessionCommand(kCommandSetPinnedState, sizeof(payload));
    843   memcpy(command->contents(), &payload, sizeof(payload));
    844   return command;
    845 }
    846 
    847 SessionCommand* SessionService::CreateSessionStorageAssociatedCommand(
    848     const SessionID& tab_id,
    849     const std::string& session_storage_persistent_id) {
    850   Pickle pickle;
    851   pickle.WriteInt(tab_id.id());
    852   pickle.WriteString(session_storage_persistent_id);
    853   return new SessionCommand(kCommandSessionStorageAssociated, pickle);
    854 }
    855 
    856 SessionCommand* SessionService::CreateSetActiveWindowCommand(
    857     const SessionID& window_id) {
    858   ActiveWindowPayload payload = 0;
    859   payload = window_id.id();
    860   SessionCommand* command =
    861       new SessionCommand(kCommandSetActiveWindow, sizeof(payload));
    862   memcpy(command->contents(), &payload, sizeof(payload));
    863   return command;
    864 }
    865 
    866 void SessionService::OnGotSessionCommands(
    867     const SessionCallback& callback,
    868     ScopedVector<SessionCommand> commands) {
    869   ScopedVector<SessionWindow> valid_windows;
    870   SessionID::id_type active_window_id = 0;
    871 
    872   RestoreSessionFromCommands(
    873       commands.get(), &valid_windows.get(), &active_window_id);
    874   callback.Run(valid_windows.Pass(), active_window_id);
    875 }
    876 
    877 void SessionService::RestoreSessionFromCommands(
    878     const std::vector<SessionCommand*>& commands,
    879     std::vector<SessionWindow*>* valid_windows,
    880     SessionID::id_type* active_window_id) {
    881   std::map<int, SessionTab*> tabs;
    882   std::map<int, SessionWindow*> windows;
    883 
    884   VLOG(1) << "RestoreSessionFromCommands " << commands.size();
    885   if (CreateTabsAndWindows(commands, &tabs, &windows, active_window_id)) {
    886     AddTabsToWindows(&tabs, &windows);
    887     SortTabsBasedOnVisualOrderAndPrune(&windows, valid_windows);
    888     UpdateSelectedTabIndex(valid_windows);
    889   }
    890   STLDeleteValues(&tabs);
    891   // Don't delete conents of windows, that is done by the caller as all
    892   // valid windows are added to valid_windows.
    893 }
    894 
    895 void SessionService::UpdateSelectedTabIndex(
    896     std::vector<SessionWindow*>* windows) {
    897   for (std::vector<SessionWindow*>::const_iterator i = windows->begin();
    898        i != windows->end(); ++i) {
    899     // See note in SessionWindow as to why we do this.
    900     int new_index = 0;
    901     for (std::vector<SessionTab*>::const_iterator j = (*i)->tabs.begin();
    902          j != (*i)->tabs.end(); ++j) {
    903       if ((*j)->tab_visual_index == (*i)->selected_tab_index) {
    904         new_index = static_cast<int>(j - (*i)->tabs.begin());
    905         break;
    906       }
    907     }
    908     (*i)->selected_tab_index = new_index;
    909   }
    910 }
    911 
    912 SessionWindow* SessionService::GetWindow(
    913     SessionID::id_type window_id,
    914     IdToSessionWindow* windows) {
    915   std::map<int, SessionWindow*>::iterator i = windows->find(window_id);
    916   if (i == windows->end()) {
    917     SessionWindow* window = new SessionWindow();
    918     window->window_id.set_id(window_id);
    919     (*windows)[window_id] = window;
    920     return window;
    921   }
    922   return i->second;
    923 }
    924 
    925 SessionTab* SessionService::GetTab(
    926     SessionID::id_type tab_id,
    927     IdToSessionTab* tabs) {
    928   DCHECK(tabs);
    929   std::map<int, SessionTab*>::iterator i = tabs->find(tab_id);
    930   if (i == tabs->end()) {
    931     SessionTab* tab = new SessionTab();
    932     tab->tab_id.set_id(tab_id);
    933     (*tabs)[tab_id] = tab;
    934     return tab;
    935   }
    936   return i->second;
    937 }
    938 
    939 std::vector<SerializedNavigationEntry>::iterator
    940   SessionService::FindClosestNavigationWithIndex(
    941     std::vector<SerializedNavigationEntry>* navigations,
    942     int index) {
    943   DCHECK(navigations);
    944   for (std::vector<SerializedNavigationEntry>::iterator
    945            i = navigations->begin(); i != navigations->end(); ++i) {
    946     if (i->index() >= index)
    947       return i;
    948   }
    949   return navigations->end();
    950 }
    951 
    952 // Function used in sorting windows. Sorting is done based on window id. As
    953 // window ids increment for each new window, this effectively sorts by creation
    954 // time.
    955 static bool WindowOrderSortFunction(const SessionWindow* w1,
    956                                     const SessionWindow* w2) {
    957   return w1->window_id.id() < w2->window_id.id();
    958 }
    959 
    960 // Compares the two tabs based on visual index.
    961 static bool TabVisualIndexSortFunction(const SessionTab* t1,
    962                                        const SessionTab* t2) {
    963   const int delta = t1->tab_visual_index - t2->tab_visual_index;
    964   return delta == 0 ? (t1->tab_id.id() < t2->tab_id.id()) : (delta < 0);
    965 }
    966 
    967 void SessionService::SortTabsBasedOnVisualOrderAndPrune(
    968     std::map<int, SessionWindow*>* windows,
    969     std::vector<SessionWindow*>* valid_windows) {
    970   std::map<int, SessionWindow*>::iterator i = windows->begin();
    971   while (i != windows->end()) {
    972     SessionWindow* window = i->second;
    973     AppType app_type = window->app_name.empty() ? TYPE_NORMAL : TYPE_APP;
    974     if (window->tabs.empty() || window->is_constrained ||
    975         !should_track_changes_for_browser_type(
    976             static_cast<Browser::Type>(window->type),
    977             app_type)) {
    978       delete window;
    979       windows->erase(i++);
    980     } else {
    981       // Valid window; sort the tabs and add it to the list of valid windows.
    982       std::sort(window->tabs.begin(), window->tabs.end(),
    983                 &TabVisualIndexSortFunction);
    984       // Otherwise, add the window such that older windows appear first.
    985       if (valid_windows->empty()) {
    986         valid_windows->push_back(window);
    987       } else {
    988         valid_windows->insert(
    989             std::upper_bound(valid_windows->begin(), valid_windows->end(),
    990                              window, &WindowOrderSortFunction),
    991             window);
    992       }
    993       ++i;
    994     }
    995   }
    996 }
    997 
    998 void SessionService::AddTabsToWindows(std::map<int, SessionTab*>* tabs,
    999                                       std::map<int, SessionWindow*>* windows) {
   1000   VLOG(1) << "AddTabsToWindws";
   1001   VLOG(1) << "Tabs " << tabs->size() << ", windows " << windows->size();
   1002   std::map<int, SessionTab*>::iterator i = tabs->begin();
   1003   while (i != tabs->end()) {
   1004     SessionTab* tab = i->second;
   1005     if (tab->window_id.id() && !tab->navigations.empty()) {
   1006       SessionWindow* window = GetWindow(tab->window_id.id(), windows);
   1007       window->tabs.push_back(tab);
   1008       tabs->erase(i++);
   1009 
   1010       // See note in SessionTab as to why we do this.
   1011       std::vector<SerializedNavigationEntry>::iterator j =
   1012           FindClosestNavigationWithIndex(&(tab->navigations),
   1013                                          tab->current_navigation_index);
   1014       if (j == tab->navigations.end()) {
   1015         tab->current_navigation_index =
   1016             static_cast<int>(tab->navigations.size() - 1);
   1017       } else {
   1018         tab->current_navigation_index =
   1019             static_cast<int>(j - tab->navigations.begin());
   1020       }
   1021     } else {
   1022       // Never got a set tab index in window, or tabs are empty, nothing
   1023       // to do.
   1024       ++i;
   1025     }
   1026   }
   1027 }
   1028 
   1029 bool SessionService::CreateTabsAndWindows(
   1030     const std::vector<SessionCommand*>& data,
   1031     std::map<int, SessionTab*>* tabs,
   1032     std::map<int, SessionWindow*>* windows,
   1033     SessionID::id_type* active_window_id) {
   1034   // If the file is corrupt (command with wrong size, or unknown command), we
   1035   // still return true and attempt to restore what we we can.
   1036   VLOG(1) << "CreateTabsAndWindows";
   1037 
   1038   startup_metric_utils::ScopedSlowStartupUMA
   1039       scoped_timer("Startup.SlowStartupSessionServiceCreateTabsAndWindows");
   1040 
   1041   for (std::vector<SessionCommand*>::const_iterator i = data.begin();
   1042        i != data.end(); ++i) {
   1043     const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
   1044     const SessionCommand* command = *i;
   1045 
   1046     VLOG(1) << "Read command " << (int) command->id();
   1047     switch (command->id()) {
   1048       case kCommandSetTabWindow: {
   1049         SessionID::id_type payload[2];
   1050         if (!command->GetPayload(payload, sizeof(payload))) {
   1051           VLOG(1) << "Failed reading command " << command->id();
   1052           return true;
   1053         }
   1054         GetTab(payload[1], tabs)->window_id.set_id(payload[0]);
   1055         break;
   1056       }
   1057 
   1058       // This is here for forward migration only.  New data is saved with
   1059       // |kCommandSetWindowBounds3|.
   1060       case kCommandSetWindowBounds2: {
   1061         WindowBoundsPayload2 payload;
   1062         if (!command->GetPayload(&payload, sizeof(payload))) {
   1063           VLOG(1) << "Failed reading command " << command->id();
   1064           return true;
   1065         }
   1066         GetWindow(payload.window_id, windows)->bounds.SetRect(payload.x,
   1067                                                               payload.y,
   1068                                                               payload.w,
   1069                                                               payload.h);
   1070         GetWindow(payload.window_id, windows)->show_state =
   1071             payload.is_maximized ?
   1072                 ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_NORMAL;
   1073         break;
   1074       }
   1075 
   1076       case kCommandSetWindowBounds3: {
   1077         WindowBoundsPayload3 payload;
   1078         if (!command->GetPayload(&payload, sizeof(payload))) {
   1079           VLOG(1) << "Failed reading command " << command->id();
   1080           return true;
   1081         }
   1082         GetWindow(payload.window_id, windows)->bounds.SetRect(payload.x,
   1083                                                               payload.y,
   1084                                                               payload.w,
   1085                                                               payload.h);
   1086         // SHOW_STATE_INACTIVE is not persisted.
   1087         ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
   1088         if (payload.show_state > ui::SHOW_STATE_DEFAULT &&
   1089             payload.show_state < ui::SHOW_STATE_END &&
   1090             payload.show_state != ui::SHOW_STATE_INACTIVE) {
   1091           show_state = static_cast<ui::WindowShowState>(payload.show_state);
   1092         } else {
   1093           NOTREACHED();
   1094         }
   1095         GetWindow(payload.window_id, windows)->show_state = show_state;
   1096         break;
   1097       }
   1098 
   1099       case kCommandSetTabIndexInWindow: {
   1100         TabIndexInWindowPayload payload;
   1101         if (!command->GetPayload(&payload, sizeof(payload))) {
   1102           VLOG(1) << "Failed reading command " << command->id();
   1103           return true;
   1104         }
   1105         GetTab(payload.id, tabs)->tab_visual_index = payload.index;
   1106         break;
   1107       }
   1108 
   1109       case kCommandTabClosedObsolete:
   1110       case kCommandWindowClosedObsolete:
   1111       case kCommandTabClosed:
   1112       case kCommandWindowClosed: {
   1113         ClosedPayload payload;
   1114         if (!command->GetPayload(&payload, sizeof(payload)) &&
   1115             !MigrateClosedPayload(*command, &payload)) {
   1116           VLOG(1) << "Failed reading command " << command->id();
   1117           return true;
   1118         }
   1119         if (command->id() == kCommandTabClosed ||
   1120             command->id() == kCommandTabClosedObsolete) {
   1121           delete GetTab(payload.id, tabs);
   1122           tabs->erase(payload.id);
   1123         } else {
   1124           delete GetWindow(payload.id, windows);
   1125           windows->erase(payload.id);
   1126         }
   1127         break;
   1128       }
   1129 
   1130       case kCommandTabNavigationPathPrunedFromBack: {
   1131         TabNavigationPathPrunedFromBackPayload payload;
   1132         if (!command->GetPayload(&payload, sizeof(payload))) {
   1133           VLOG(1) << "Failed reading command " << command->id();
   1134           return true;
   1135         }
   1136         SessionTab* tab = GetTab(payload.id, tabs);
   1137         tab->navigations.erase(
   1138             FindClosestNavigationWithIndex(&(tab->navigations), payload.index),
   1139             tab->navigations.end());
   1140         break;
   1141       }
   1142 
   1143       case kCommandTabNavigationPathPrunedFromFront: {
   1144         TabNavigationPathPrunedFromFrontPayload payload;
   1145         if (!command->GetPayload(&payload, sizeof(payload)) ||
   1146             payload.index <= 0) {
   1147           VLOG(1) << "Failed reading command " << command->id();
   1148           return true;
   1149         }
   1150         SessionTab* tab = GetTab(payload.id, tabs);
   1151 
   1152         // Update the selected navigation index.
   1153         tab->current_navigation_index =
   1154             std::max(-1, tab->current_navigation_index - payload.index);
   1155 
   1156         // And update the index of existing navigations.
   1157         for (std::vector<SerializedNavigationEntry>::iterator
   1158                  i = tab->navigations.begin();
   1159              i != tab->navigations.end();) {
   1160           i->set_index(i->index() - payload.index);
   1161           if (i->index() < 0)
   1162             i = tab->navigations.erase(i);
   1163           else
   1164             ++i;
   1165         }
   1166         break;
   1167       }
   1168 
   1169       case kCommandUpdateTabNavigation: {
   1170         SerializedNavigationEntry navigation;
   1171         SessionID::id_type tab_id;
   1172         if (!RestoreUpdateTabNavigationCommand(
   1173                 *command, &navigation, &tab_id)) {
   1174           VLOG(1) << "Failed reading command " << command->id();
   1175           return true;
   1176         }
   1177         SessionTab* tab = GetTab(tab_id, tabs);
   1178         std::vector<SerializedNavigationEntry>::iterator i =
   1179             FindClosestNavigationWithIndex(&(tab->navigations),
   1180                                            navigation.index());
   1181         if (i != tab->navigations.end() && i->index() == navigation.index())
   1182           *i = navigation;
   1183         else
   1184           tab->navigations.insert(i, navigation);
   1185         break;
   1186       }
   1187 
   1188       case kCommandSetSelectedNavigationIndex: {
   1189         SelectedNavigationIndexPayload payload;
   1190         if (!command->GetPayload(&payload, sizeof(payload))) {
   1191           VLOG(1) << "Failed reading command " << command->id();
   1192           return true;
   1193         }
   1194         GetTab(payload.id, tabs)->current_navigation_index = payload.index;
   1195         break;
   1196       }
   1197 
   1198       case kCommandSetSelectedTabInIndex: {
   1199         SelectedTabInIndexPayload payload;
   1200         if (!command->GetPayload(&payload, sizeof(payload))) {
   1201           VLOG(1) << "Failed reading command " << command->id();
   1202           return true;
   1203         }
   1204         GetWindow(payload.id, windows)->selected_tab_index = payload.index;
   1205         break;
   1206       }
   1207 
   1208       case kCommandSetWindowType: {
   1209         WindowTypePayload payload;
   1210         if (!command->GetPayload(&payload, sizeof(payload))) {
   1211           VLOG(1) << "Failed reading command " << command->id();
   1212           return true;
   1213         }
   1214         GetWindow(payload.id, windows)->is_constrained = false;
   1215         GetWindow(payload.id, windows)->type =
   1216             BrowserTypeForWindowType(
   1217                 static_cast<WindowType>(payload.index));
   1218         break;
   1219       }
   1220 
   1221       case kCommandSetPinnedState: {
   1222         PinnedStatePayload payload;
   1223         if (!command->GetPayload(&payload, sizeof(payload))) {
   1224           VLOG(1) << "Failed reading command " << command->id();
   1225           return true;
   1226         }
   1227         GetTab(payload.tab_id, tabs)->pinned = payload.pinned_state;
   1228         break;
   1229       }
   1230 
   1231       case kCommandSetWindowAppName: {
   1232         SessionID::id_type window_id;
   1233         std::string app_name;
   1234         if (!RestoreSetWindowAppNameCommand(*command, &window_id, &app_name))
   1235           return true;
   1236 
   1237         GetWindow(window_id, windows)->app_name.swap(app_name);
   1238         break;
   1239       }
   1240 
   1241       case kCommandSetExtensionAppID: {
   1242         SessionID::id_type tab_id;
   1243         std::string extension_app_id;
   1244         if (!RestoreSetTabExtensionAppIDCommand(
   1245                 *command, &tab_id, &extension_app_id)) {
   1246           VLOG(1) << "Failed reading command " << command->id();
   1247           return true;
   1248         }
   1249 
   1250         GetTab(tab_id, tabs)->extension_app_id.swap(extension_app_id);
   1251         break;
   1252       }
   1253 
   1254       case kCommandSetTabUserAgentOverride: {
   1255         SessionID::id_type tab_id;
   1256         std::string user_agent_override;
   1257         if (!RestoreSetTabUserAgentOverrideCommand(
   1258                 *command, &tab_id, &user_agent_override)) {
   1259           return true;
   1260         }
   1261 
   1262         GetTab(tab_id, tabs)->user_agent_override.swap(user_agent_override);
   1263         break;
   1264       }
   1265 
   1266       case kCommandSessionStorageAssociated: {
   1267         scoped_ptr<Pickle> command_pickle(command->PayloadAsPickle());
   1268         SessionID::id_type command_tab_id;
   1269         std::string session_storage_persistent_id;
   1270         PickleIterator iter(*command_pickle.get());
   1271         if (!command_pickle->ReadInt(&iter, &command_tab_id) ||
   1272             !command_pickle->ReadString(&iter, &session_storage_persistent_id))
   1273           return true;
   1274         // Associate the session storage back.
   1275         GetTab(command_tab_id, tabs)->session_storage_persistent_id =
   1276             session_storage_persistent_id;
   1277         break;
   1278       }
   1279 
   1280       case kCommandSetActiveWindow: {
   1281         ActiveWindowPayload payload;
   1282         if (!command->GetPayload(&payload, sizeof(payload))) {
   1283           VLOG(1) << "Failed reading command " << command->id();
   1284           return true;
   1285         }
   1286         *active_window_id = payload;
   1287         break;
   1288       }
   1289 
   1290       default:
   1291         VLOG(1) << "Failed reading an unknown command " << command->id();
   1292         return true;
   1293     }
   1294   }
   1295   return true;
   1296 }
   1297 
   1298 void SessionService::BuildCommandsForTab(const SessionID& window_id,
   1299                                          WebContents* tab,
   1300                                          int index_in_window,
   1301                                          bool is_pinned,
   1302                                          std::vector<SessionCommand*>* commands,
   1303                                          IdToRange* tab_to_available_range) {
   1304   DCHECK(tab && commands && window_id.id());
   1305   SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
   1306   const SessionID& session_id(session_tab_helper->session_id());
   1307   commands->push_back(CreateSetTabWindowCommand(window_id, session_id));
   1308 
   1309   const int current_index = tab->GetController().GetCurrentEntryIndex();
   1310   const int min_index = std::max(0,
   1311                                  current_index - max_persist_navigation_count);
   1312   const int max_index =
   1313       std::min(current_index + max_persist_navigation_count,
   1314                tab->GetController().GetEntryCount());
   1315   const int pending_index = tab->GetController().GetPendingEntryIndex();
   1316   if (tab_to_available_range) {
   1317     (*tab_to_available_range)[session_id.id()] =
   1318         std::pair<int, int>(min_index, max_index);
   1319   }
   1320 
   1321   if (is_pinned) {
   1322     commands->push_back(CreatePinnedStateCommand(session_id, true));
   1323   }
   1324 
   1325   extensions::TabHelper* extensions_tab_helper =
   1326       extensions::TabHelper::FromWebContents(tab);
   1327   if (extensions_tab_helper->extension_app()) {
   1328     commands->push_back(
   1329         CreateSetTabExtensionAppIDCommand(
   1330             kCommandSetExtensionAppID, session_id.id(),
   1331             extensions_tab_helper->extension_app()->id()));
   1332   }
   1333 
   1334   const std::string& ua_override = tab->GetUserAgentOverride();
   1335   if (!ua_override.empty()) {
   1336     commands->push_back(
   1337         CreateSetTabUserAgentOverrideCommand(
   1338             kCommandSetTabUserAgentOverride, session_id.id(), ua_override));
   1339   }
   1340 
   1341   for (int i = min_index; i < max_index; ++i) {
   1342     const NavigationEntry* entry = (i == pending_index) ?
   1343         tab->GetController().GetPendingEntry() :
   1344         tab->GetController().GetEntryAtIndex(i);
   1345     DCHECK(entry);
   1346     if (ShouldTrackEntry(entry->GetVirtualURL())) {
   1347       const SerializedNavigationEntry navigation =
   1348           SerializedNavigationEntry::FromNavigationEntry(i, *entry);
   1349       commands->push_back(
   1350           CreateUpdateTabNavigationCommand(
   1351               kCommandUpdateTabNavigation, session_id.id(), navigation));
   1352     }
   1353   }
   1354   commands->push_back(
   1355       CreateSetSelectedNavigationIndexCommand(session_id, current_index));
   1356 
   1357   if (index_in_window != -1) {
   1358     commands->push_back(
   1359         CreateSetTabIndexInWindowCommand(session_id, index_in_window));
   1360   }
   1361 
   1362   // Record the association between the sessionStorage namespace and the tab.
   1363   content::SessionStorageNamespace* session_storage_namespace =
   1364       tab->GetController().GetDefaultSessionStorageNamespace();
   1365   ScheduleCommand(CreateSessionStorageAssociatedCommand(
   1366       session_tab_helper->session_id(),
   1367       session_storage_namespace->persistent_id()));
   1368 }
   1369 
   1370 void SessionService::BuildCommandsForBrowser(
   1371     Browser* browser,
   1372     std::vector<SessionCommand*>* commands,
   1373     IdToRange* tab_to_available_range,
   1374     std::set<SessionID::id_type>* windows_to_track) {
   1375   DCHECK(browser && commands);
   1376   DCHECK(browser->session_id().id());
   1377 
   1378   commands->push_back(
   1379       CreateSetWindowBoundsCommand(browser->session_id(),
   1380                                    browser->window()->GetRestoredBounds(),
   1381                                    browser->window()->GetRestoredState()));
   1382 
   1383   commands->push_back(CreateSetWindowTypeCommand(
   1384       browser->session_id(), WindowTypeForBrowserType(browser->type())));
   1385 
   1386   if (!browser->app_name().empty()) {
   1387     commands->push_back(CreateSetWindowAppNameCommand(
   1388         kCommandSetWindowAppName,
   1389         browser->session_id().id(),
   1390         browser->app_name()));
   1391   }
   1392 
   1393   windows_to_track->insert(browser->session_id().id());
   1394   TabStripModel* tab_strip = browser->tab_strip_model();
   1395   for (int i = 0; i < tab_strip->count(); ++i) {
   1396     WebContents* tab = tab_strip->GetWebContentsAt(i);
   1397     DCHECK(tab);
   1398     BuildCommandsForTab(browser->session_id(), tab, i,
   1399                         tab_strip->IsTabPinned(i),
   1400                         commands, tab_to_available_range);
   1401   }
   1402 
   1403   commands->push_back(
   1404       CreateSetSelectedTabInWindow(browser->session_id(),
   1405                                    browser->tab_strip_model()->active_index()));
   1406 }
   1407 
   1408 void SessionService::BuildCommandsFromBrowsers(
   1409     std::vector<SessionCommand*>* commands,
   1410     IdToRange* tab_to_available_range,
   1411     std::set<SessionID::id_type>* windows_to_track) {
   1412   DCHECK(commands);
   1413   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
   1414     Browser* browser = *it;
   1415     // Make sure the browser has tabs and a window. Browser's destructor
   1416     // removes itself from the BrowserList. When a browser is closed the
   1417     // destructor is not necessarily run immediately. This means it's possible
   1418     // for us to get a handle to a browser that is about to be removed. If
   1419     // the tab count is 0 or the window is NULL, the browser is about to be
   1420     // deleted, so we ignore it.
   1421     if (ShouldTrackBrowser(browser) && browser->tab_strip_model()->count() &&
   1422         browser->window()) {
   1423       BuildCommandsForBrowser(browser, commands, tab_to_available_range,
   1424                               windows_to_track);
   1425     }
   1426   }
   1427 }
   1428 
   1429 void SessionService::ScheduleReset() {
   1430   set_pending_reset(true);
   1431   STLDeleteElements(&pending_commands());
   1432   tab_to_available_range_.clear();
   1433   windows_tracking_.clear();
   1434   BuildCommandsFromBrowsers(&pending_commands(), &tab_to_available_range_,
   1435                             &windows_tracking_);
   1436   if (!windows_tracking_.empty()) {
   1437     // We're lazily created on startup and won't get an initial batch of
   1438     // SetWindowType messages. Set these here to make sure our state is correct.
   1439     has_open_trackable_browsers_ = true;
   1440     move_on_new_browser_ = true;
   1441   }
   1442   StartSaveTimer();
   1443 }
   1444 
   1445 bool SessionService::ReplacePendingCommand(SessionCommand* command) {
   1446   // We optimize page navigations, which can happen quite frequently and
   1447   // are expensive. And activation is like Highlander, there can only be one!
   1448   if (command->id() != kCommandUpdateTabNavigation &&
   1449       command->id() != kCommandSetActiveWindow) {
   1450     return false;
   1451   }
   1452   for (std::vector<SessionCommand*>::reverse_iterator i =
   1453        pending_commands().rbegin(); i != pending_commands().rend(); ++i) {
   1454     SessionCommand* existing_command = *i;
   1455     if (command->id() == kCommandUpdateTabNavigation &&
   1456         existing_command->id() == kCommandUpdateTabNavigation) {
   1457       scoped_ptr<Pickle> command_pickle(command->PayloadAsPickle());
   1458       PickleIterator iterator(*command_pickle);
   1459       SessionID::id_type command_tab_id;
   1460       int command_nav_index;
   1461       if (!command_pickle->ReadInt(&iterator, &command_tab_id) ||
   1462           !command_pickle->ReadInt(&iterator, &command_nav_index)) {
   1463         return false;
   1464       }
   1465       SessionID::id_type existing_tab_id;
   1466       int existing_nav_index;
   1467       {
   1468         // Creating a pickle like this means the Pickle references the data from
   1469         // the command. Make sure we delete the pickle before the command, else
   1470         // the pickle references deleted memory.
   1471         scoped_ptr<Pickle> existing_pickle(existing_command->PayloadAsPickle());
   1472         iterator = PickleIterator(*existing_pickle);
   1473         if (!existing_pickle->ReadInt(&iterator, &existing_tab_id) ||
   1474             !existing_pickle->ReadInt(&iterator, &existing_nav_index)) {
   1475           return false;
   1476         }
   1477       }
   1478       if (existing_tab_id == command_tab_id &&
   1479           existing_nav_index == command_nav_index) {
   1480         // existing_command is an update for the same tab/index pair. Replace
   1481         // it with the new one. We need to add to the end of the list just in
   1482         // case there is a prune command after the update command.
   1483         delete existing_command;
   1484         pending_commands().erase(i.base() - 1);
   1485         pending_commands().push_back(command);
   1486         return true;
   1487       }
   1488       return false;
   1489     }
   1490     if (command->id() == kCommandSetActiveWindow &&
   1491         existing_command->id() == kCommandSetActiveWindow) {
   1492       *i = command;
   1493       delete existing_command;
   1494       return true;
   1495     }
   1496   }
   1497   return false;
   1498 }
   1499 
   1500 void SessionService::ScheduleCommand(SessionCommand* command) {
   1501   DCHECK(command);
   1502   if (ReplacePendingCommand(command))
   1503     return;
   1504   BaseSessionService::ScheduleCommand(command);
   1505   // Don't schedule a reset on tab closed/window closed. Otherwise we may
   1506   // lose tabs/windows we want to restore from if we exit right after this.
   1507   if (!pending_reset() && pending_window_close_ids_.empty() &&
   1508       commands_since_reset() >= kWritesPerReset &&
   1509       (command->id() != kCommandTabClosed &&
   1510        command->id() != kCommandWindowClosed)) {
   1511     ScheduleReset();
   1512   }
   1513 }
   1514 
   1515 void SessionService::CommitPendingCloses() {
   1516   for (PendingTabCloseIDs::iterator i = pending_tab_close_ids_.begin();
   1517        i != pending_tab_close_ids_.end(); ++i) {
   1518     ScheduleCommand(CreateTabClosedCommand(*i));
   1519   }
   1520   pending_tab_close_ids_.clear();
   1521 
   1522   for (PendingWindowCloseIDs::iterator i = pending_window_close_ids_.begin();
   1523        i != pending_window_close_ids_.end(); ++i) {
   1524     ScheduleCommand(CreateWindowClosedCommand(*i));
   1525   }
   1526   pending_window_close_ids_.clear();
   1527 }
   1528 
   1529 bool SessionService::IsOnlyOneTabLeft() const {
   1530   if (!profile() || profile()->AsTestingProfile()) {
   1531     // We're testing, always return false.
   1532     return false;
   1533   }
   1534 
   1535   int window_count = 0;
   1536   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
   1537     Browser* browser = *it;
   1538     const SessionID::id_type window_id = browser->session_id().id();
   1539     if (ShouldTrackBrowser(browser) &&
   1540         window_closing_ids_.find(window_id) == window_closing_ids_.end()) {
   1541       if (++window_count > 1)
   1542         return false;
   1543       // By the time this is invoked the tab has been removed. As such, we use
   1544       // > 0 here rather than > 1.
   1545       if (browser->tab_strip_model()->count() > 0)
   1546         return false;
   1547     }
   1548   }
   1549   return true;
   1550 }
   1551 
   1552 bool SessionService::HasOpenTrackableBrowsers(
   1553     const SessionID& window_id) const {
   1554   if (!profile() || profile()->AsTestingProfile()) {
   1555     // We're testing, always return true.
   1556     return true;
   1557   }
   1558 
   1559   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
   1560     Browser* browser = *it;
   1561     const SessionID::id_type browser_id = browser->session_id().id();
   1562     if (browser_id != window_id.id() &&
   1563         window_closing_ids_.find(browser_id) == window_closing_ids_.end() &&
   1564         ShouldTrackBrowser(browser)) {
   1565       return true;
   1566     }
   1567   }
   1568   return false;
   1569 }
   1570 
   1571 bool SessionService::ShouldTrackChangesToWindow(
   1572     const SessionID& window_id) const {
   1573   return windows_tracking_.find(window_id.id()) != windows_tracking_.end();
   1574 }
   1575 
   1576 bool SessionService::ShouldTrackBrowser(Browser* browser) const {
   1577   if (browser->profile() != profile())
   1578     return false;
   1579   // Never track app popup windows that do not have a trusted source (i.e.
   1580   // popup windows spawned by an app). If this logic changes, be sure to also
   1581   // change SessionRestoreImpl::CreateRestoredBrowser().
   1582   if (browser->is_app() && browser->is_type_popup() &&
   1583       !browser->is_trusted_source()) {
   1584     return false;
   1585   }
   1586   AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
   1587   return should_track_changes_for_browser_type(browser->type(), app_type);
   1588 }
   1589 
   1590 bool SessionService::should_track_changes_for_browser_type(Browser::Type type,
   1591                                                            AppType app_type) {
   1592 #if defined(OS_CHROMEOS)
   1593   // Restore app popups for chromeos alone.
   1594   if (type == Browser::TYPE_POPUP && app_type == TYPE_APP)
   1595     return true;
   1596 #endif
   1597 
   1598   return type == Browser::TYPE_TABBED;
   1599 }
   1600 
   1601 SessionService::WindowType SessionService::WindowTypeForBrowserType(
   1602     Browser::Type type) {
   1603   switch (type) {
   1604     case Browser::TYPE_POPUP:
   1605       return TYPE_POPUP;
   1606     case Browser::TYPE_TABBED:
   1607       return TYPE_TABBED;
   1608     default:
   1609       DCHECK(false);
   1610       return TYPE_TABBED;
   1611   }
   1612 }
   1613 
   1614 Browser::Type SessionService::BrowserTypeForWindowType(WindowType type) {
   1615   switch (type) {
   1616     case TYPE_POPUP:
   1617       return Browser::TYPE_POPUP;
   1618     case TYPE_TABBED:
   1619     default:
   1620       return Browser::TYPE_TABBED;
   1621   }
   1622 }
   1623 
   1624 void SessionService::RecordSessionUpdateHistogramData(int type,
   1625     base::TimeTicks* last_updated_time) {
   1626   if (!last_updated_time->is_null()) {
   1627     base::TimeDelta delta = base::TimeTicks::Now() - *last_updated_time;
   1628     // We're interested in frequent updates periods longer than
   1629     // 10 minutes.
   1630     bool use_long_period = false;
   1631     if (delta >= save_delay_in_mins_) {
   1632       use_long_period = true;
   1633     }
   1634     switch (type) {
   1635       case chrome::NOTIFICATION_SESSION_SERVICE_SAVED :
   1636         RecordUpdatedSaveTime(delta, use_long_period);
   1637         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
   1638         break;
   1639       case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
   1640         RecordUpdatedTabClosed(delta, use_long_period);
   1641         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
   1642         break;
   1643       case content::NOTIFICATION_NAV_LIST_PRUNED:
   1644         RecordUpdatedNavListPruned(delta, use_long_period);
   1645         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
   1646         break;
   1647       case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
   1648         RecordUpdatedNavEntryCommit(delta, use_long_period);
   1649         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
   1650         break;
   1651       default:
   1652         NOTREACHED() << "Bad type sent to RecordSessionUpdateHistogramData";
   1653         break;
   1654     }
   1655   }
   1656   (*last_updated_time) = base::TimeTicks::Now();
   1657 }
   1658 
   1659 void SessionService::RecordUpdatedTabClosed(base::TimeDelta delta,
   1660                                             bool use_long_period) {
   1661   std::string name("SessionRestore.TabClosedPeriod");
   1662   UMA_HISTOGRAM_CUSTOM_TIMES(name,
   1663       delta,
   1664       // 2500ms is the default save delay.
   1665       save_delay_in_millis_,
   1666       save_delay_in_mins_,
   1667       50);
   1668   if (use_long_period) {
   1669     std::string long_name_("SessionRestore.TabClosedLongPeriod");
   1670     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
   1671         delta,
   1672         save_delay_in_mins_,
   1673         save_delay_in_hrs_,
   1674         50);
   1675   }
   1676 }
   1677 
   1678 void SessionService::RecordUpdatedNavListPruned(base::TimeDelta delta,
   1679                                                 bool use_long_period) {
   1680   std::string name("SessionRestore.NavigationListPrunedPeriod");
   1681   UMA_HISTOGRAM_CUSTOM_TIMES(name,
   1682       delta,
   1683       // 2500ms is the default save delay.
   1684       save_delay_in_millis_,
   1685       save_delay_in_mins_,
   1686       50);
   1687   if (use_long_period) {
   1688     std::string long_name_("SessionRestore.NavigationListPrunedLongPeriod");
   1689     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
   1690         delta,
   1691         save_delay_in_mins_,
   1692         save_delay_in_hrs_,
   1693         50);
   1694   }
   1695 }
   1696 
   1697 void SessionService::RecordUpdatedNavEntryCommit(base::TimeDelta delta,
   1698                                                  bool use_long_period) {
   1699   std::string name("SessionRestore.NavEntryCommittedPeriod");
   1700   UMA_HISTOGRAM_CUSTOM_TIMES(name,
   1701       delta,
   1702       // 2500ms is the default save delay.
   1703       save_delay_in_millis_,
   1704       save_delay_in_mins_,
   1705       50);
   1706   if (use_long_period) {
   1707     std::string long_name_("SessionRestore.NavEntryCommittedLongPeriod");
   1708     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
   1709         delta,
   1710         save_delay_in_mins_,
   1711         save_delay_in_hrs_,
   1712         50);
   1713   }
   1714 }
   1715 
   1716 void SessionService::RecordUpdatedSessionNavigationOrTab(base::TimeDelta delta,
   1717                                                          bool use_long_period) {
   1718   std::string name("SessionRestore.NavOrTabUpdatePeriod");
   1719   UMA_HISTOGRAM_CUSTOM_TIMES(name,
   1720       delta,
   1721       // 2500ms is the default save delay.
   1722       save_delay_in_millis_,
   1723       save_delay_in_mins_,
   1724       50);
   1725   if (use_long_period) {
   1726     std::string long_name_("SessionRestore.NavOrTabUpdateLongPeriod");
   1727     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
   1728         delta,
   1729         save_delay_in_mins_,
   1730         save_delay_in_hrs_,
   1731         50);
   1732   }
   1733 }
   1734 
   1735 void SessionService::RecordUpdatedSaveTime(base::TimeDelta delta,
   1736                                            bool use_long_period) {
   1737   std::string name("SessionRestore.SavePeriod");
   1738   UMA_HISTOGRAM_CUSTOM_TIMES(name,
   1739       delta,
   1740       // 2500ms is the default save delay.
   1741       save_delay_in_millis_,
   1742       save_delay_in_mins_,
   1743       50);
   1744   if (use_long_period) {
   1745     std::string long_name_("SessionRestore.SaveLongPeriod");
   1746     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
   1747         delta,
   1748         save_delay_in_mins_,
   1749         save_delay_in_hrs_,
   1750         50);
   1751   }
   1752 }
   1753 
   1754 void SessionService::TabInserted(WebContents* contents) {
   1755   SessionTabHelper* session_tab_helper =
   1756       SessionTabHelper::FromWebContents(contents);
   1757   if (!ShouldTrackChangesToWindow(session_tab_helper->window_id()))
   1758     return;
   1759   SetTabWindow(session_tab_helper->window_id(),
   1760                session_tab_helper->session_id());
   1761   extensions::TabHelper* extensions_tab_helper =
   1762       extensions::TabHelper::FromWebContents(contents);
   1763   if (extensions_tab_helper &&
   1764       extensions_tab_helper->extension_app()) {
   1765     SetTabExtensionAppID(
   1766         session_tab_helper->window_id(),
   1767         session_tab_helper->session_id(),
   1768         extensions_tab_helper->extension_app()->id());
   1769   }
   1770 
   1771   // Record the association between the SessionStorageNamespace and the
   1772   // tab.
   1773   //
   1774   // TODO(ajwong): This should be processing the whole map rather than
   1775   // just the default. This in particular will not work for tabs with only
   1776   // isolated apps which won't have a default partition.
   1777   content::SessionStorageNamespace* session_storage_namespace =
   1778       contents->GetController().GetDefaultSessionStorageNamespace();
   1779   ScheduleCommand(CreateSessionStorageAssociatedCommand(
   1780       session_tab_helper->session_id(),
   1781       session_storage_namespace->persistent_id()));
   1782   session_storage_namespace->SetShouldPersist(true);
   1783 }
   1784 
   1785 void SessionService::TabClosing(WebContents* contents) {
   1786   // Allow the associated sessionStorage to get deleted; it won't be needed
   1787   // in the session restore.
   1788   content::SessionStorageNamespace* session_storage_namespace =
   1789       contents->GetController().GetDefaultSessionStorageNamespace();
   1790   session_storage_namespace->SetShouldPersist(false);
   1791   SessionTabHelper* session_tab_helper =
   1792       SessionTabHelper::FromWebContents(contents);
   1793   TabClosed(session_tab_helper->window_id(),
   1794             session_tab_helper->session_id(),
   1795             contents->GetClosedByUserGesture());
   1796   RecordSessionUpdateHistogramData(content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
   1797                                    &last_updated_tab_closed_time_);
   1798 }
   1799 
   1800 void SessionService::MaybeDeleteSessionOnlyData() {
   1801   // Don't try anything if we're testing.  The browser_process is not fully
   1802   // created and DeleteSession will crash if we actually attempt it.
   1803   if (!profile() || profile()->AsTestingProfile())
   1804     return;
   1805 
   1806   // Clear session data if the last window for a profile has been closed and
   1807   // closing the last window would normally close Chrome, unless background mode
   1808   // is active.  Tests don't have a background_mode_manager.
   1809   if (has_open_trackable_browsers_ ||
   1810       browser_defaults::kBrowserAliveWithNoWindows ||
   1811       g_browser_process->background_mode_manager()->IsBackgroundModeActive()) {
   1812     return;
   1813   }
   1814 
   1815   // Check for any open windows for the current profile that we aren't tracking.
   1816   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
   1817     if ((*it)->profile() == profile())
   1818       return;
   1819   }
   1820   DeleteSessionOnlyData(profile());
   1821 }
   1822