Extract chrome.runtime API code from extensions::EventRouter

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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
-#include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/activity_log/activity_log.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_host.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 16 matching lines @@
 namespace {
 
 void NotifyEventListenerRemovedOnIOThread(
     void* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       browser_context, extension_id, sub_event_name);
 }
 
-// TODO(jamescook): Move this to RuntimeEventRouter.
-void DispatchOnInstalledEvent(
-    BrowserContext* browser_context,
-    const std::string& extension_id,
-    const Version& old_version,
-    bool chrome_updated) {
-  if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
-    return;
-
-  RuntimeEventRouter::DispatchOnInstalledEvent(browser_context, extension_id,
-                                               old_version, chrome_updated);
-}
-
 void DoNothing(ExtensionHost* host) {}
 
 // A dictionary of event names to lists of filters that this extension has
 // registered from its lazy background page.
 const char kFilteredEvents[] = "filtered_events";
 
 }  // namespace
 
 const char EventRouter::kRegisteredEvents[] = "events";
 
@@ skipping 90 matching lines @@
       FROM_HERE,
       base::Bind(&EventRouter::IncrementInFlightEventsOnUI,
                   browser_context_id,
                   extension_id));
 }
 
 EventRouter::EventRouter(BrowserContext* browser_context,
                          ExtensionPrefs* extension_prefs)
     : browser_context_(browser_context),
       extension_prefs_(extension_prefs),
-      listeners_(this),
-      dispatch_chrome_updated_event_(false) {
+      listeners_(this) {
   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<BrowserContext>(browser_context_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
                  content::Source<BrowserContext>(browser_context_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<BrowserContext>(browser_context_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<BrowserContext>(browser_context_));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
-                 content::Source<BrowserContext>(browser_context_));
-
-  // Check if registered events are up-to-date. We can only do this once
-  // per browser context, since it updates internal state when called.
-  dispatch_chrome_updated_event_ =
-      ExtensionsBrowserClient::Get()->DidVersionUpdate(extension_prefs_);
 }
 
 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 507 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_ENABLED: {
       // If the extension has a lazy background page, make sure it gets loaded
       // to register the events the extension is interested in.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
         LazyBackgroundTaskQueue* queue = ExtensionSystem::GetForBrowserContext(
             browser_context_)->lazy_background_task_queue();
         queue->AddPendingTask(browser_context_, extension->id(),
                               base::Bind(&DoNothing));
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       std::set<std::string> registered_events =
           GetRegisteredEvents(extension->id());
       listeners_.LoadUnfilteredLazyListeners(extension->id(),
                                              registered_events);
       const DictionaryValue* filtered_events =
           GetFilteredEvents(extension->id());
       if (filtered_events)
         listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
-
-      if (dispatch_chrome_updated_event_) {
-        base::MessageLoop::current()->PostTask(
-            FROM_HERE,
-            base::Bind(&DispatchOnInstalledEvent,
-                       browser_context_,
-                       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 InstalledExtensionInfo>(details)->extension;
-
-      // Get the previous version, if this is an upgrade.
-      ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-          browser_context_)->extension_service();
-      const Extension* old = service->GetExtensionById(extension->id(), true);
-      Version old_version;
-      if (old)
-        old_version = *old->version();
-
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&DispatchOnInstalledEvent,
-                     browser_context_,
-                     extension->id(),
-                     old_version,
-                     false));
-      break;
-    }
     default:
       NOTREACHED();
       return;
   }
 }
 
 Event::Event(const std::string& event_name,
              scoped_ptr<base::ListValue> event_args)
     : event_name(event_name),
       event_args(event_args.Pass()),
@@ skipping 39 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions