Restart running apps when chrome restarts.

chrome/browser/sessions/session_service.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sessions/session_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/extensions/tab_helper.h"
+#include "chrome/browser/extensions/extension_host.h"

[marja, 2012/08/23 07:31:18]

The #include order is wrong.

[koz (OOO until 15th September), 2012/08/23 07:59:04]

Done.

 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 36 matching lines @@
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
 static const SessionCommand::id_type kCommandSetWindowAppName = 15;
 static const SessionCommand::id_type kCommandTabClosed = 16;
 static const SessionCommand::id_type kCommandWindowClosed = 17;
 static const SessionCommand::id_type kCommandSetTabUserAgentOverride = 18;
 static const SessionCommand::id_type kCommandSessionStorageAssociated = 19;
+static const SessionCommand::id_type kCommandAppStarted = 20;
+static const SessionCommand::id_type kCommandAppStopped = 21;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
 // The callback from GetLastSession is internally routed to SessionService
 // first and then the caller. This is done so that the SessionWindows can be
 // recreated from the SessionCommands and the SessionWindows passed to the
 // caller. The following class is used for this.
@@ skipping 443 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::NotificationService::AllSources());
   // Wait for NOTIFICATION_BROWSER_WINDOW_READY so that is_app() is set.
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
       content::NotificationService::AllSources());
+  registrar_.Add(
+      this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+      content::NotificationService::AllSources());
+  registrar_.Add(
+      this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
+      content::NotificationService::AllSources());
 }
 
 bool SessionService::ShouldNewWindowStartSession() {
   // ChromeOS and OSX have different ideas of application lifetime than
   // the other platforms.
   // On ChromeOS opening a new window should never start a new session.
 #if defined(OS_CHROMEOS)
   if (!force_browser_not_alive_with_no_windows_)
     return false;
 #endif
@@ skipping 170 matching lines @@
       if (extension_tab_helper->extension_app()) {
         RestoreTabHelper* helper =
             extension_tab_helper->tab_contents()->restore_tab_helper();
         SetTabExtensionAppID(helper->window_id(),
                              helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
     }
 
+    case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING: {
+      extensions::ExtensionHost* host =
+          content::Details<extensions::ExtensionHost>(details).ptr();
+      active_extensions_.insert(host);
+      if (host->extension()->is_platform_app())
+        ScheduleCommand(CreateRunAppCommand(host->extension()->id()));
+      break;
+    }
+
+    case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
+      extensions::ExtensionHost* host =
+          content::Details<extensions::ExtensionHost>(details).ptr();
+      if (host->extension()->is_platform_app())
+        ScheduleCommand(CreateStopAppCommand(host->extension()->id()));
+      break;
+    }
+
     default:
       NOTREACHED();
   }
 }
 
 void SessionService::SetTabExtensionAppID(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& extension_app_id) {
   if (!ShouldTrackChangesToWindow(window_id))
@@ skipping 122 matching lines @@
 
 SessionCommand* SessionService::CreateSessionStorageAssociatedCommand(
     const SessionID& tab_id,
     const std::string& session_storage_persistent_id) {
   Pickle pickle;
   pickle.WriteInt(tab_id.id());
   pickle.WriteString(session_storage_persistent_id);
   return new SessionCommand(kCommandSessionStorageAssociated, pickle);
 }
 
+SessionCommand* SessionService::CreateRunAppCommand(
+    const std::string& extension_id) {
+  Pickle pickle;
+  pickle.WriteString(extension_id);
+  return new SessionCommand(kCommandAppStarted, pickle);
+}
+
+SessionCommand* SessionService::CreateStopAppCommand(
+    const std::string& extension_id) {
+  Pickle pickle;
+  pickle.WriteString(extension_id);
+  return new SessionCommand(kCommandAppStopped, pickle);
+}
+
 void SessionService::OnGotSessionCommands(
     Handle handle,
     scoped_refptr<InternalGetCommandsRequest> request) {
   if (request->canceled())
     return;
 
   ScopedVector<SessionWindow> valid_windows;
+  std::set<std::string> apps;
   RestoreSessionFromCommands(
-      request->commands, &(valid_windows.get()));
+      request->commands, &(valid_windows.get()), &apps);
   static_cast<InternalSessionRequest*>(request.get())->
-      real_callback.Run(request->handle(), &(valid_windows.get()));
+      real_callback.Run(request->handle(), &(valid_windows.get()), &apps);
 }
 
 void SessionService::RestoreSessionFromCommands(
     const std::vector<SessionCommand*>& commands,
-    std::vector<SessionWindow*>* valid_windows) {
+    std::vector<SessionWindow*>* valid_windows,
+    std::set<std::string>* apps) {
   std::map<int, SessionTab*> tabs;
   std::map<int, SessionWindow*> windows;
 
   VLOG(1) << "RestoreSessionFromCommands " << commands.size();
-  if (CreateTabsAndWindows(commands, &tabs, &windows)) {
+  if (CreateTabsAndWindows(commands, &tabs, &windows, apps)) {
     AddTabsToWindows(&tabs, &windows);
     SortTabsBasedOnVisualOrderAndPrune(&windows, valid_windows);
     UpdateSelectedTabIndex(valid_windows);
   }
   STLDeleteValues(&tabs);
   // Don't delete conents of windows, that is done by the caller as all
   // valid windows are added to valid_windows.
 }
 
 void SessionService::UpdateSelectedTabIndex(
@@ skipping 126 matching lines @@
       // Never got a set tab index in window, or tabs are empty, nothing
       // to do.
       ++i;
     }
   }
 }
 
 bool SessionService::CreateTabsAndWindows(
     const std::vector<SessionCommand*>& data,
     std::map<int, SessionTab*>* tabs,
-    std::map<int, SessionWindow*>* windows) {
+    std::map<int, SessionWindow*>* windows,
+    std::set<std::string>* apps) {
   // If the file is corrupt (command with wrong size, or unknown command), we
   // still return true and attempt to restore what we we can.
   VLOG(1) << "CreateTabsAndWindows";
 
   for (std::vector<SessionCommand*>::const_iterator i = data.begin();
        i != data.end(); ++i) {
     const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
     const SessionCommand* command = *i;
 
     VLOG(1) << "Read command " << (int) command->id();
@@ skipping 222 matching lines @@
         PickleIterator iter(*command_pickle.get());
         if (!command_pickle->ReadInt(&iter, &command_tab_id) ||
             !command_pickle->ReadString(&iter, &session_storage_persistent_id))
           return true;
         // Associate the session storage back.
         GetTab(command_tab_id, tabs)->session_storage_persistent_id =
             session_storage_persistent_id;
         break;
       }
 
+      case kCommandAppStarted: {
+        scoped_ptr<Pickle> command_pickle(command->PayloadAsPickle());
+        PickleIterator iter(*command_pickle);
+        std::string extension_id;
+        if (!command_pickle->ReadString(&iter, &extension_id)) {
+          return true;
+        }
+        apps->insert(extension_id);
+        break;
+      }
+
+      case kCommandAppStopped: {
+        scoped_ptr<Pickle> command_pickle(command->PayloadAsPickle());
+        PickleIterator iter(*command_pickle);
+        std::string extension_id;
+        if (!command_pickle->ReadString(&iter, &extension_id)) {
+          return true;
+        }
+        apps->erase(extension_id);
+        break;
+      }
+
       default:
         VLOG(1) << "Failed reading an unknown command " << command->id();
         return true;
     }
   }
   return true;
 }
 
 void SessionService::BuildCommandsForTab(
     const SessionID& window_id,
@@ skipping 130 matching lines @@
     AppType app_type = browser->is_app() ? TYPE_APP : TYPE_NORMAL;
     if (should_track_changes_for_browser_type(browser->type(), app_type) &&
         browser->tab_count() &&
         browser->window()) {
       BuildCommandsForBrowser(browser, commands, tab_to_available_range,
                               windows_to_track);
     }
   }
 }
 
 void SessionService::ScheduleReset() {

[marja, 2012/08/23 07:31:18]

You'd need some code to recreate the app started / stopped information about the
apps here.

You can try this out by setting kWritesPerReset above to a low value, so you'll
force recreating the session restore data repeatedly. Afaics, in this version,
the commands (kCommandAppStarted and kCommandAppStopped) you've added will get
lost after a reset.

[koz (OOO until 15th September), 2012/08/23 07:59:05]

Ah, I see. Yes, you're right. I've added a BuildCommandsFromRunningApps() which
is analogous to BuildCommandsFromBrowsers().

   set_pending_reset(true);
   STLDeleteElements(&pending_commands());
   tab_to_available_range_.clear();
   windows_tracking_.clear();
   BuildCommandsFromBrowsers(&pending_commands(), &tab_to_available_range_,
                             &windows_tracking_);
   if (!windows_tracking_.empty()) {
     // We're lazily created on startup and won't get an initial batch of
     // SetWindowType messages. Set these here to make sure our state is correct.
     has_open_trackable_browsers_ = true;
@@ skipping 287 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }