Add chrome.runtime.onStartup, which is fired on browser start.

chrome/browser/extensions/extension_process_manager.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
+#include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 59 matching lines @@
                        const content::NotificationDetails& details);
 
   // Returns true if the extension is allowed to run in incognito mode.
   bool IsIncognitoEnabled(const Extension* extension);
 
   ExtensionProcessManager* original_manager_;
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ExtensionProcessManager* manager, const Extension* extension) {
-  if (extension->has_persistent_background_page()) {
+  if (extension->has_persistent_background_page())
     manager->CreateBackgroundHost(extension, extension->GetBackgroundURL());
+}
+
+static void CreateBackgroundHostsForProfileStartup(
+    Profile* profile,
+    ExtensionProcessManager* manager,
+    const ExtensionSet* extensions) {
+  for (ExtensionSet::const_iterator extension = extensions->begin();
+       extension != extensions->end(); ++extension) {
+    CreateBackgroundHostForExtensionLoad(manager, *extension);
+
+    extensions::RuntimeEventRouter::DispatchOnStartupEvent(
+        profile, (*extension)->id());
   }
 }
 
-static void CreateBackgroundHostsForProfileStartup(
-    ExtensionProcessManager* manager, const ExtensionSet* extensions) {
-  for (ExtensionSet::const_iterator extension = extensions->begin();
-       extension != extensions->end(); ++extension) {
-    CreateBackgroundHostForExtensionLoad(manager, *extension);
-  }
-}
-
 }  // namespace
 
 struct ExtensionProcessManager::BackgroundPageData {
   // The count of things keeping the lazy background page alive.
   int lazy_keepalive_count;
 
   // This is used with the ShouldUnload message, to ensure that the extension
   // remained idle between sending the message and receiving the ack.
   int close_sequence_id;
 
@@ skipping 435 matching lines @@
     DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
-      CreateBackgroundHostsForProfileStartup(this,
-          content::Source<Profile>(source).ptr()->
-              GetExtensionService()->extensions());
+      Profile* profile = content::Source<Profile>(source).ptr();
+      CreateBackgroundHostsForProfileStartup(profile, this,
+          profile->GetExtensionService()->extensions());
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
-      ExtensionService* service =
-          content::Source<Profile>(source).ptr()->GetExtensionService();
+      Profile* profile = content::Source<Profile>(source).ptr();
+      ExtensionService* service = profile->GetExtensionService();
       if (service->is_ready()) {
         const Extension* extension =
             content::Details<const Extension>(details).ptr();
-        ::CreateBackgroundHostForExtensionLoad(this, extension);
+        CreateBackgroundHostForExtensionLoad(this, extension);
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const Extension* extension =
           content::Details<extensions::UnloadedExtensionInfo>(
               details)->extension;
       for (ExtensionHostSet::iterator iter = background_hosts_.begin();
            iter != background_hosts_.end(); ++iter) {
@@ skipping 215 matching lines @@
       // We want to spawn our background hosts as soon as the user opens an
       // incognito window. Watch for new browsers and create the hosts if
       // it matches our profile.
       Browser* browser = content::Source<Browser>(source).ptr();
       if (browser->profile() == site_instance_->GetBrowserContext()) {
         // On Chrome OS, a login screen is implemented as a browser.
         // This browser has no extension service.  In this case,
         // service will be NULL.
         ExtensionService* service = GetProfile()->GetExtensionService();
         if (service && service->is_ready())
-          CreateBackgroundHostsForProfileStartup(this, service->extensions());
+          CreateBackgroundHostsForProfileStartup(GetProfile(),
+                                                 this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }