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

chrome/browser/extensions/event_router.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/event_router.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/processes/processes_api.h"
 #include "chrome/browser/extensions/api/processes/processes_api_constants.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/extension_devtools_manager.h"
 #include "chrome/browser/extensions/extension_host.h"
+#include "chrome/browser/extensions/extension_prefs.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/event_names.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/extensions/system_info_event_router.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 18 matching lines @@
     void* profile,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       profile, extension_id, sub_event_name);
 }
 
 void DispatchOnInstalledEvent(
     Profile* profile,
     const std::string& extension_id,
-    const Version& old_version) {
+    const Version& old_version,
+    bool chrome_updated) {
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return;
 
   RuntimeEventRouter::DispatchOnInstalledEvent(profile, extension_id,
-                                               old_version);
+                                               old_version, chrome_updated);
 }
 
 }  // namespace
 
 struct EventRouter::ListenerProcess {
   content::RenderProcessHost* process;
   std::string extension_id;
 
   ListenerProcess(content::RenderProcessHost* process,
                   const std::string& extension_id)
@@ skipping 35 matching lines @@
                                 const std::string& extension_id,
                                 const std::string& event_name,
                                 scoped_ptr<ListValue> event_args,
                                 const GURL& event_url,
                                 UserGestureState user_gesture,
                                 const EventFilteringInfo& info) {
   DispatchExtensionMessage(ipc_sender, extension_id, event_name,
                            event_args.get(), event_url, user_gesture, info);
 }
 
-EventRouter::EventRouter(Profile* profile)
+EventRouter::EventRouter(Profile* profile, ExtensionPrefs* extension_prefs)
     : profile_(profile),
       extension_devtools_manager_(
           ExtensionSystem::Get(profile)->devtools_manager()),
-      listeners_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      listeners_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      dispatch_chrome_updated_event_(false) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
+                 content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_));
+
+  // NULL in unit_tests.
+  if (extension_prefs) {
+    // Check if registered events are up-to-date. We need to do this before
+    // reading the registered events, because it deletes them if they're out of
+    // date.
+    dispatch_chrome_updated_event_ =
+        !extension_prefs->CheckRegisteredEventsUpToDate();
+  }
 }
 
 EventRouter::~EventRouter() {}
 
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
       event_name, extension_id, process, scoped_ptr<DictionaryValue>())));
 }
@@ skipping 405 matching lines @@
                           const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       content::RenderProcessHost* renderer =
           content::Source<content::RenderProcessHost>(source).ptr();
       // Remove all event listeners associated with this renderer.
       listeners_.RemoveListenersForProcess(renderer);
       break;
     }
+    case chrome::NOTIFICATION_EXTENSIONS_READY: {
+      // We're done restarting Chrome after an update.
+      dispatch_chrome_updated_event_ = false;
+      break;
+    }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       ExtensionPrefs* prefs =
           profile_->GetExtensionService()->extension_prefs();
       std::set<std::string> registered_events =
           prefs->GetRegisteredEvents(extension->id());
       listeners_.LoadUnfilteredLazyListeners(extension->id(),
                                              registered_events);
       const DictionaryValue* filtered_events =
           prefs->GetFilteredEvents(extension->id());
       if (filtered_events)
         listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
+
+      if (dispatch_chrome_updated_event_) {
+        MessageLoop::current()->PostTask(FROM_HERE,
+            base::Bind(&DispatchOnInstalledEvent, profile_, extension->id(),
+                       Version(), true));
+      }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       // Remove all registered lazy listeners from our cache.
       UnloadedExtensionInfo* unloaded =
           content::Details<UnloadedExtensionInfo>(details).ptr();
       listeners_.RemoveLazyListenersForExtension(unloaded->extension->id());
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       // Dispatch the onInstalled event.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
 
       // Get the previous version, if this is an upgrade.
       ExtensionService* service =
           ExtensionSystem::Get(profile_)->extension_service();
       const Extension* old = service->GetExtensionById(extension->id(), true);
       Version old_version;
       if (old)
         old_version = *old->version();
 
       MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(&DispatchOnInstalledEvent, profile_, extension->id(),
-                     old_version));
+                     old_version, false));
       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
 Event::Event(const std::string& event_name,
              scoped_ptr<ListValue> event_args,
@@ skipping 20 matching lines @@
       event_args(event_args.Pass()),
       event_url(event_url),
       restrict_to_profile(restrict_to_profile),
       cross_incognito_args(NULL),
       user_gesture(user_gesture),
       info(info) {}
 
 Event::~Event() {}
 
 }  // namespace extensions