Add the basic code skeleton for system info event router

chrome/browser/extensions/system_info_event_router.h

Index: chrome/browser/extensions/system_info_event_router.h
diff --git a/chrome/browser/extensions/system_info_event_router.h b/chrome/browser/extensions/system_info_event_router.h
new file mode 100644
index 0000000000000000000000000000000000000000..cfecd04ecf1ed9dc561f3abfb73c48659ad3ac41
--- /dev/null
+++ b/chrome/browser/extensions/system_info_event_router.h
@@ -0,0 +1,64 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_SYSTEM_INFO_EVENT_ROUTER_H_
+#define CHROME_BROWSER_EXTENSIONS_SYSTEM_INFO_EVENT_ROUTER_H_
+
+#include "base/file_path.h"
+#include "base/memory/singleton.h"
+#include "base/values.h"
+#include "chrome/browser/profiles/profile.h"
+
+namespace extensions {
+
+// Event router for systemInfo API. It is a singleton instance shared by
+// multiple profiles.
+// TODO(hongbo): It should derive from SystemMonitor::DevicesChangedObserver.
+// Since the system_monitor will be refactored along with media_gallery, once
+// http://crbug.com/145400 is fixed, We need to update SystemInfoEventRouter

[Mihai Parparita -not on Chrome, 2012/08/31 01:01:00]

Nit: lowercase the "We".

[Hongbo Min, 2012/08/31 15:29:53]

Done.

+// accordingly.
+class SystemInfoEventRouter {
+ public:
+  static SystemInfoEventRouter* GetInstance();
+
+  // Add/remove event listener for the |event_name| event from |profile|.
+  void AddEventListener(Profile* profile, const std::string& event_name);
+  void RemoveEventListener(Profile* profile, const std::string& event_name);
+
+  // Return true if the |event_name| event is already being listened.
+  bool HasEventListener(const std::string& event_name);
+
+  // Return true if the |event_name| is an event from systemInfo namespace.
+  static bool IsSystemInfoEvent(const std::string& event_name);
+
+  // TODO(hongbo): The following methods should be likely overriden from
+  // SystemMonitor::DevicesChangedObserver once the http://crbug.com/145400
+  // is fixed.
+  void OnStorageAvailableCapacityChanged(const std::string& id,
+                                         int64 available_capacity);
+  void OnRemovableStorageAttached(const std::string& id,
+                                  const string16& name,
+                                  const FilePath::StringType& location);
+  void OnRemovableStorageDetached(const std::string& id);
+
+ private:
+  friend struct DefaultSingletonTraits<SystemInfoEventRouter>;
+  // Mapping of the profile and the event names that are being listened on it.
+  typedef std::map<Profile*, std::set<std::string> > EventListenerMap;

[Mihai Parparita -not on Chrome, 2012/08/31 01:01:00]

I'm concerned about holding on to Profile pointers, since profiles can be loaded
and unloaded.

Instead of that optimization, why not get the ExtensionEventRouter for the
default profile (which is always loaded) and then call DispatchEventToRenderers
without a restricted profile, which will dispatch that event to all extensions
in all profiles that have a listener attached (similar to
http://code.google.com/searchframe#OAMlx_jo-ck/src/chrome/browser/extensions/...).
EventRouter::DispatchEventImpl ends up doing filtering before sending IPCs, so
it's not inefficient to send it to all profiles from your code.

[Hongbo Min, 2012/08/31 15:29:53]

The ProfileManager::GetDefaultProfile is deprecated as commented in
profile_manager.h.

According to
http://www.chromium.org/developers/design-documents/multiple-profiles, it says: 
"You should no longer use it to get a "Default" profile, because this concept
will in the future no longer exist."


So I use a map to record which events are listened on each Profile instance
loaded, and dispatch event using event router for each Profile instead of using
that for Default Profile.

I add IsValideProfile to check whether the profile is valid to avoid referencing
a unloaded Profile instance you concerned.

[Mihai Parparita -not on Chrome, 2012/08/31 21:37:38]

True. However, I'd still like to not worry about Profiles if at all possible. It
looks like the better way is to use EventRouterForwarder, which has a
BroadcastEventToRenderers method.

(you can get at the event router via
g_browser_process->extension_event_router_forwarder()

+
+  SystemInfoEventRouter();
+  virtual ~SystemInfoEventRouter();
+
+  // Called on the UI thread to dispatch the systemInfo event to all extension
+  // processes cross multiple profiles.
+  void DispatchEvent(const std::string& event_name,
+                     const base::ListValue& args);
+
+  EventListenerMap event_listener_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(SystemInfoEventRouter);
+};
+
+}  // namespace extensions
+#endif  // CHROME_BROWSER_EXTENSIONS_SYSTEM_INFO_EVENT_ROUTER_H_