chrome/browser/sessions/session_service.cc

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