Base infrastructure for Networking Private API on Windows and Mac.

chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc

Index: chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc b/chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc
index 969983372c020f27957faf31f93150a6d8beff9b..cac1383b8fced8008b46d36b20280f080213093c 100644
--- a/chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc
+++ b/chrome/browser/extensions/api/networking_private/networking_private_event_router_chromeos.cc
@@ -15,19 +15,50 @@
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/network_state_handler_observer.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-using extensions::EventRouter;
-using extensions::ExtensionSystem;
-namespace api = extensions::api::networking_private;
+namespace extensions {
 
-namespace chromeos {
+class NetworkingPrivateEventRouterImpl
+    : public NetworkingPrivateEventRouter,
+      public chromeos::NetworkStateHandlerObserver {
+ public:
+  explicit NetworkingPrivateEventRouterImpl(Profile* profile);
+  virtual ~NetworkingPrivateEventRouterImpl();
 
-NetworkingPrivateEventRouter::NetworkingPrivateEventRouter(Profile* profile)
+ protected:
+  // BrowserContextKeyedService overrides:
+  virtual void Shutdown() OVERRIDE;
+
+  // EventRouter::Observer overrides:
+  virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
+  virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
+
+  // NetworkStateHandlerObserver overrides:
+  virtual void NetworkListChanged() OVERRIDE;
+  virtual void NetworkPropertiesUpdated(
+      const chromeos::NetworkState* network) OVERRIDE;
+
+ private:
+  // Decide if we should listen for network changes or not. If there are any
+  // JavaScript listeners registered for the onNetworkChanged event, then we
+  // want to register for change notification from the network state handler.
+  // Otherwise, we want to unregister and not be listening to network changes.
+  void StartOrStopListeningForNetworkChanges();
+
+  Profile* profile_;
+  bool listening_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateEventRouterImpl);
+};
+
+NetworkingPrivateEventRouterImpl::NetworkingPrivateEventRouterImpl(
+    Profile* profile)
     : profile_(profile), listening_(false) {
   // Register with the event router so we know when renderers are listening to
   // our events. We first check and see if there *is* an event router, because
@@ -36,18 +67,18 @@ NetworkingPrivateEventRouter::NetworkingPrivateEventRouter(Profile* profile)
   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
   if (event_router) {
     event_router->RegisterObserver(
-        this, api::OnNetworksChanged::kEventName);
+        this, api::networking_private::OnNetworksChanged::kEventName);
     event_router->RegisterObserver(
-        this, api::OnNetworkListChanged::kEventName);
+        this, api::networking_private::OnNetworkListChanged::kEventName);
     StartOrStopListeningForNetworkChanges();
   }
 }
 
-NetworkingPrivateEventRouter::~NetworkingPrivateEventRouter() {
+NetworkingPrivateEventRouterImpl::~NetworkingPrivateEventRouterImpl() {
   DCHECK(!listening_);
 }
 
-void NetworkingPrivateEventRouter::Shutdown() {
+void NetworkingPrivateEventRouterImpl::Shutdown() {
   // Unregister with the event router. We first check and see if there *is* an
   // event router, because some unit tests try to shutdown all profile services,
   // but didn't initialize the event router first.
@@ -56,46 +87,50 @@ void NetworkingPrivateEventRouter::Shutdown() {
     event_router->UnregisterObserver(this);
 
   if (listening_) {
-    NetworkHandler::Get()->network_state_handler()->RemoveObserver(
+    chromeos::NetworkHandler::Get()->network_state_handler()->RemoveObserver(
         this, FROM_HERE);
   }
   listening_ = false;
 }
 
-void NetworkingPrivateEventRouter::OnListenerAdded(
-    const extensions::EventListenerInfo& details) {
+void NetworkingPrivateEventRouterImpl::OnListenerAdded(
+    const EventListenerInfo& details) {
   // Start listening to events from the network state handler.
   StartOrStopListeningForNetworkChanges();
 }
 
-void NetworkingPrivateEventRouter::OnListenerRemoved(
-    const extensions::EventListenerInfo& details) {
+void NetworkingPrivateEventRouterImpl::OnListenerRemoved(
+    const EventListenerInfo& details) {
   // Stop listening to events from the network state handler if there are no
   // more listeners.
   StartOrStopListeningForNetworkChanges();
 }
 
-void NetworkingPrivateEventRouter::StartOrStopListeningForNetworkChanges() {
+void NetworkingPrivateEventRouterImpl::StartOrStopListeningForNetworkChanges() {
   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
   bool should_listen =
-      event_router->HasEventListener(api::OnNetworksChanged::kEventName) ||
-      event_router->HasEventListener(api::OnNetworkListChanged::kEventName);
+      event_router->HasEventListener(
+          api::networking_private::OnNetworksChanged::kEventName) ||
+      event_router->HasEventListener(
+          api::networking_private::OnNetworkListChanged::kEventName);
 
   if (should_listen && !listening_) {
-    NetworkHandler::Get()->network_state_handler()->AddObserver(
+    chromeos::NetworkHandler::Get()->network_state_handler()->AddObserver(
         this, FROM_HERE);
   } else if (!should_listen && listening_) {
-    NetworkHandler::Get()->network_state_handler()->RemoveObserver(
+    chromeos::NetworkHandler::Get()->network_state_handler()->RemoveObserver(
         this, FROM_HERE);
   }
   listening_ = should_listen;
 }
 
-void NetworkingPrivateEventRouter::NetworkListChanged() {
+void NetworkingPrivateEventRouterImpl::NetworkListChanged() {
   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
-  NetworkStateHandler::NetworkStateList networks;
-  NetworkHandler::Get()->network_state_handler()->GetNetworkList(&networks);
-  if (!event_router->HasEventListener(api::OnNetworkListChanged::kEventName)) {
+  chromeos::NetworkStateHandler::NetworkStateList networks;
+  chromeos::NetworkHandler::Get()->network_state_handler()->GetNetworkList(
+      &networks);
+  if (!event_router->HasEventListener(
+           api::networking_private::OnNetworkListChanged::kEventName)) {
     // TODO(stevenjb): Remove logging once crbug.com/256881 is fixed
     // (or at least reduce to LOG_DEBUG). Same with NET_LOG events below.
     NET_LOG_EVENT("NetworkingPrivate.NetworkListChanged: No Listeners", "");
@@ -105,36 +140,45 @@ void NetworkingPrivateEventRouter::NetworkListChanged() {
   NET_LOG_EVENT("NetworkingPrivate.NetworkListChanged", "");
 
   std::vector<std::string> changes;
-  for (NetworkStateHandler::NetworkStateList::const_iterator iter =
-           networks.begin(); iter != networks.end(); ++iter) {
+  for (chromeos::NetworkStateHandler::NetworkStateList::const_iterator iter =
+           networks.begin();
+       iter != networks.end();
+       ++iter) {
     // TODO(gspencer): Currently the "GUID" is actually the service path. Fix
     // this to be the real GUID once we're using
     // ManagedNetworkConfigurationManager.
     changes.push_back((*iter)->path());
   }
 
-  scoped_ptr<base::ListValue> args(api::OnNetworkListChanged::Create(changes));
-  scoped_ptr<extensions::Event> extension_event(new extensions::Event(
-      api::OnNetworkListChanged::kEventName, args.Pass()));
+  scoped_ptr<base::ListValue> args(
+      api::networking_private::OnNetworkListChanged::Create(changes));
+  scoped_ptr<Event> extension_event(new Event(
+      api::networking_private::OnNetworkListChanged::kEventName, args.Pass()));
   event_router->BroadcastEvent(extension_event.Pass());
 }
 
-void NetworkingPrivateEventRouter::NetworkPropertiesUpdated(
-    const NetworkState* network) {
+void NetworkingPrivateEventRouterImpl::NetworkPropertiesUpdated(
+    const chromeos::NetworkState* network) {
   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
-  if (!event_router->HasEventListener(api::OnNetworksChanged::kEventName)) {
+  if (!event_router->HasEventListener(
+           api::networking_private::OnNetworksChanged::kEventName)) {
     NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated: No Listeners",
                   network->path());
     return;
   }
   NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated",
                 network->path());
-  scoped_ptr<base::ListValue> args(api::OnNetworksChanged::Create(
-      std::vector<std::string>(1, network->path())));
-  scoped_ptr<extensions::Event> extension_event(
-      new extensions::Event(api::OnNetworksChanged::kEventName, args.Pass()));
+  scoped_ptr<base::ListValue> args(
+      api::networking_private::OnNetworksChanged::Create(
+          std::vector<std::string>(1, network->path())));
+  scoped_ptr<Event> extension_event(new Event(
+      api::networking_private::OnNetworksChanged::kEventName, args.Pass()));
   event_router->BroadcastEvent(extension_event.Pass());
 }
 
-}  // namespace chromeos
+NetworkingPrivateEventRouter* NetworkingPrivateEventRouter::Create(
+    Profile* profile) {
+  return new NetworkingPrivateEventRouterImpl(profile);
+}
 
+}  // namespace extensions