Lazy initialization for ProcessesEventRouter.

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.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/extensions/api/processes/processes_api_constants.h"
-#include "chrome/browser/extensions/api/processes/processes_api.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/event_names.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/lazy_background_task_queue.h"
@@ skipping 85 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, ExtensionPrefs* extension_prefs)
+EventRouter::EventRouter(Profile* profile)
     : profile_(profile),
-      extension_devtools_manager_(
-          ExtensionSystem::Get(profile)->devtools_manager()),
       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::InitWithPrefs(ExtensionPrefs* 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();
+}
+
 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>())));
 }
 
 void EventRouter::RemoveEventListener(const std::string& event_name,
                                       content::RenderProcessHost* process,
                                       const std::string& extension_id) {
   EventListener listener(event_name, extension_id, process,
                          scoped_ptr<DictionaryValue>());
   listeners_.RemoveListener(&listener);
 }
 
+void EventRouter::RegisterObserver(Observer* observer,
+                                   const std::string& event_name) {
+  observers_[event_name] = observer;
+}
+
+void EventRouter::UnregisterObserver(Observer* observer) {
+  std::vector<ObserverMap::iterator> iters_to_remove;
+  for (ObserverMap::iterator iter = observers_.begin();
+       iter != observers_.end(); ++iter) {
+    if (iter->second == observer)
+      iters_to_remove.push_back(iter);
+  }
+  for (size_t i = 0; i < iters_to_remove.size(); ++i)
+    observers_.erase(iters_to_remove[i]);
+}
+
 void EventRouter::OnListenerAdded(const EventListener* listener) {
   // We don't care about lazy events being added.
   if (!listener->process)
     return;
 
-  if (extension_devtools_manager_.get())
-    extension_devtools_manager_->AddEventListener(listener->event_name,
-                                                  listener->process->GetID());
+  const std::string& event_name = listener->event_name;
+  ObserverMap::iterator observer = observers_.find(event_name);
+  if (observer != observers_.end())
+    observer->second->OnListenerAdded(event_name);
 
-  // We lazily tell the TaskManager to start updating when listeners to the
-  // processes.onUpdated or processes.onUpdatedWithMemory events arrive.
-  const std::string& event_name = listener->event_name;
-  if (event_name.compare(
-          extensions::processes_api_constants::kOnUpdated) == 0 ||
-      event_name.compare(
-          extensions::processes_api_constants::kOnUpdatedWithMemory) == 0)
-    extensions::ProcessesEventRouter::GetInstance()->ListenerAdded();
+  ExtensionDevToolsManager* extension_devtools_manager =

[Aaron Boodman, 2012/11/07 23:51:28]

Add a TODO to get rid of this?

Also, out of curiosity, how do you plan to do it, since this client wants all
events, not just particular ones?

[Yoyo Zhou, 2012/11/08 00:18:16]

Done.
Probably I'd just have another class of observer.

+      ExtensionSystem::Get(profile_)->devtools_manager();
+  if (extension_devtools_manager)
+    extension_devtools_manager->AddEventListener(event_name,
+                                                 listener->process->GetID());
 
   if (SystemInfoEventRouter::IsSystemInfoEvent(event_name))
     SystemInfoEventRouter::GetInstance()->AddEventListener(event_name);
 }
 
 void EventRouter::OnListenerRemoved(const EventListener* listener) {
   // We don't care about lazy events being removed.
   if (!listener->process)
     return;
 
   const std::string& event_name = listener->event_name;
-  if (extension_devtools_manager_.get())
-    extension_devtools_manager_->RemoveEventListener(
+  ObserverMap::iterator observer = observers_.find(event_name);
+  if (observer != observers_.end())
+    observer->second->OnListenerRemoved(event_name);
+
+  ExtensionDevToolsManager* extension_devtools_manager =
+      ExtensionSystem::Get(profile_)->devtools_manager();
+  if (extension_devtools_manager)
+    extension_devtools_manager->RemoveEventListener(
         event_name, listener->process->GetID());
 
-  // If a processes.onUpdated or processes.onUpdatedWithMemory event listener
-  // is removed (or a process with one exits), then we let the extension API
-  // know that it has one fewer listener.
-  if (event_name.compare(
-          extensions::processes_api_constants::kOnUpdated) == 0 ||
-      event_name.compare(
-          extensions::processes_api_constants::kOnUpdatedWithMemory) == 0)
-    extensions::ProcessesEventRouter::GetInstance()->ListenerRemoved();
-
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&NotifyEventListenerRemovedOnIOThread,
-                 profile_, listener->extension_id, listener->event_name));
+                 profile_, listener->extension_id, event_name));
 
   if (SystemInfoEventRouter::IsSystemInfoEvent(event_name))
     SystemInfoEventRouter::GetInstance()->RemoveEventListener(event_name);
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   scoped_ptr<EventListener> listener(new EventListener(
       event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
   bool is_new = listeners_.AddListener(listener.Pass());
@@ skipping 451 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