Restart running apps when chrome restarts.

chrome/browser/sessions/session_restore.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_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/app_runtime/app_runtime_api.h"
+#include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/performance_monitor/startup_timer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabrestore.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
@@ skipping 484 matching lines @@
     session_service->GetLastSession(
         &request_consumer_,
         base::Bind(&SessionRestoreImpl::OnGotSession, base::Unretained(this)));
 
     if (synchronous_) {
       {
         MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
         MessageLoop::current()->Run();
       }
       Browser* browser = ProcessSessionWindows(&windows_);
+      ProcessSessionApps(&apps_);
       delete this;
       return browser;
     }
 
     if (browser_) {
       registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                      content::Source<Browser>(browser_));
     }
 
     return browser_;
@@ skipping 160 matching lines @@
     }
 
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-End", false);
 #endif
     return browser;
   }
 
   void OnGotSession(SessionService::Handle handle,
-                    std::vector<SessionWindow*>* windows) {
+                    std::vector<SessionWindow*>* windows,
+                    std::set<std::string>* apps) {
     base::TimeDelta time_to_got_sessions =
         base::TimeTicks::Now() - restore_started_;
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "SessionRestore.TimeToGotSessions",
         time_to_got_sessions,
         base::TimeDelta::FromMilliseconds(10),
         base::TimeDelta::FromSeconds(1000),
         100);
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-GotSession", false);
 #endif
     if (synchronous_) {
       // See comment above windows_ as to why we don't process immediately.
       windows_.swap(*windows);
+      apps_.swap(*apps);
       MessageLoop::current()->QuitNow();
       return;
     }
 
     ProcessSessionWindows(windows);
+    ProcessSessionApps(apps);
+  }
+
+  void ProcessSessionApps(std::set<std::string>* apps) {
+    for (std::set<std::string>::const_iterator it = apps->begin();
+        it != apps->end(); it++) {
+      const extensions::Extension* extension =
+          extensions::ExtensionSystem::Get(profile_)->extension_service()->
+          extensions()->GetByID(*it);
+      extensions::AppEventRouter::DispatchOnRestartEvent(profile_, extension);
+    }
   }
 
   Browser* ProcessSessionWindows(std::vector<SessionWindow*>* windows) {
     VLOG(1) << "ProcessSessionWindows " << windows->size();
     base::TimeDelta time_to_process_sessions =
         base::TimeTicks::Now() - restore_started_;
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "SessionRestore.TimeToProcessSessions",
         time_to_process_sessions,
         base::TimeDelta::FromMilliseconds(10),
@@ skipping 291 matching lines @@
   CancelableRequestConsumer request_consumer_;
 
   // Responsible for loading the tabs.
   scoped_refptr<TabLoader> tab_loader_;
 
   // When synchronous we run a nested message loop. To avoid creating windows
   // from the nested message loop (which can make exiting the nested message
   // loop take a while) we cache the SessionWindows here and create the actual
   // windows when the nested message loop exits.
   std::vector<SessionWindow*> windows_;
+  std::set<std::string> apps_;

[sky, 2012/08/23 16:23:52]

newline between 1056/1057 and document what apps_ is.

[koz (OOO until 15th September), 2012/08/24 02:08:57]

Done.

 
   content::NotificationRegistrar registrar_;
 
   // The time we started the restore.
   base::TimeTicks restore_started_;
 
   // Set to true after the first browser is shown.
   bool browser_shown_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionRestoreImpl);
@@ skipping 58 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }