Reset registered events and dispatch runtime.onInstalled to all extensions when

chrome/browser/extensions/api/runtime/runtime_api.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/extensions/api/runtime/runtime_api.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/extension.h"
 #include "googleurl/src/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 const char kOnStartupEvent[] = "runtime.onStartup";
 const char kOnInstalledEvent[] = "runtime.onInstalled";
 const char kNoBackgroundPageError[] = "You do not have a background page.";
 const char kPageLoadError[] = "Background page failed to load.";
 const char kInstallReason[] = "reason";
+const char kInstallReasonChromeUpdate[] = "chrome_update";
 const char kInstallReasonUpdate[] = "update";
 const char kInstallReasonInstall[] = "install";
 const char kInstallPreviousVersion[] = "previousVersion";
 
 static void DispatchOnStartupEventImpl(
     Profile* profile,
     const std::string& extension_id,
     bool first_call,
     ExtensionHost* host) {
   // A NULL host from the LazyBackgroundTaskQueue means the page failed to
@@ skipping 33 matching lines @@
 // static
 void RuntimeEventRouter::DispatchOnStartupEvent(
     Profile* profile, const std::string& extension_id) {
   DispatchOnStartupEventImpl(profile, extension_id, true, NULL);
 }
 
 // static
 void RuntimeEventRouter::DispatchOnInstalledEvent(
     Profile* profile,
     const std::string& extension_id,
-    const Version& old_version) {
+    const Version& old_version,
+    bool chrome_updated) {
   ExtensionSystem* system = ExtensionSystem::Get(profile);
   if (!system)
     return;
 
   // Special case: normally, extensions add their own lazy event listeners.
   // However, since the extension has just been installed, it hasn't had a
   // chance to register for events. So we register on its behalf. If the
   // extension does not actually have a listener, the event will just be
   // ignored.
   scoped_ptr<base::ListValue> event_args(new ListValue());
   base::DictionaryValue* info = new base::DictionaryValue();
   event_args->Append(info);
-  info->SetString(kInstallReason,
-      old_version.IsValid() ? kInstallReasonUpdate : kInstallReasonInstall);
-  if (old_version.IsValid())
+  if (old_version.IsValid()) {
+    info->SetString(kInstallReason, kInstallReasonUpdate);
     info->SetString(kInstallPreviousVersion, old_version.GetString());
+  } else if (chrome_updated) {
+    info->SetString(kInstallReason, kInstallReasonChromeUpdate);
+  } else {
+    info->SetString(kInstallReason, kInstallReasonInstall);
+  }
   system->event_router()->AddLazyEventListener(kOnInstalledEvent, extension_id);
   system->event_router()->DispatchEventToExtension(
       extension_id, kOnInstalledEvent, event_args.Pass(), NULL, GURL());
   system->event_router()->RemoveLazyEventListener(kOnInstalledEvent,
                                                   extension_id);
 }
 
 bool RuntimeGetBackgroundPageFunction::RunImpl() {
   ExtensionHost* host =
       ExtensionSystem::Get(profile())->process_manager()->
@@ skipping 17 matching lines @@
 void RuntimeGetBackgroundPageFunction::OnPageLoaded(ExtensionHost* host) {
   if (host) {
     SendResponse(true);
   } else {
     error_ = kPageLoadError;
     SendResponse(false);
   }
 }
 
 }   // namespace extensions