Base infrastructure for Networking Private API on Windows and Mac.

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

Index: chrome/browser/extensions/api/networking_private/networking_private_event_router_nonchromeos.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_event_router_nonchromeos.cc b/chrome/browser/extensions/api/networking_private/networking_private_event_router_nonchromeos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cf243f9c8b865d480ad58d89c17c626f4aa90826
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_private/networking_private_event_router_nonchromeos.cc
@@ -0,0 +1,78 @@
+// Copyright 2013 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/api/networking_private/networking_private_event_router.h"
+
+#include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
+#include "chrome/browser/extensions/api/networking_private/networking_private_process_client.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/api/networking_private.h"
+
+namespace extensions {
+
+NetworkingPrivateEventRouter::NetworkingPrivateEventRouter(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
+  // some unit tests try to create all profile services, but don't initialize
+  // the event router first.
+  EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
+  if (event_router) {
+    event_router->RegisterObserver(
+        this,
+        api::networking_private::OnNetworksChanged::kEventName);
+    event_router->RegisterObserver(
+        this,
+        api::networking_private::OnNetworkListChanged::kEventName);
+    StartOrStopListeningForNetworkChanges();
+  }
+}
+
+NetworkingPrivateEventRouter::~NetworkingPrivateEventRouter() {
+  DCHECK(!listening_);
+}
+
+void NetworkingPrivateEventRouter::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.
+  EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
+  if (event_router)
+    event_router->UnregisterObserver(this);
+
+  listening_ = false;
+}
+
+void NetworkingPrivateEventRouter::OnListenerAdded(
+    const extensions::EventListenerInfo& details) {
+  // Start listening to events from the network state handler.
+  StartOrStopListeningForNetworkChanges();
+}
+
+void NetworkingPrivateEventRouter::OnListenerRemoved(
+    const extensions::EventListenerInfo& details) {
+  // Stop listening to events from the network state handler if there are no
+  // more listeners.
+  StartOrStopListeningForNetworkChanges();
+}
+
+void NetworkingPrivateEventRouter::StartOrStopListeningForNetworkChanges() {
+  EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
+  bool should_listen =
+      event_router->HasEventListener(
+          api::networking_private::OnNetworksChanged::kEventName) ||
+      event_router->HasEventListener(api::networking_private::
+                                         OnNetworkListChanged::kEventName);
+

[tbarzic, 2013/10/12 02:14:09]

Shouldn't you create the NetworkingPrivateProcessClient in case (should_listen
&& !listenning_).

+  if (!should_listen && listening_) {
+    scoped_refptr<NetworkingPrivateProcessClient> process_client(
+        NetworkingPrivateProcessClient::GetProcessClientForProfile(profile_));
+    process_client->ShutdownProcessClient();

[tbarzic, 2013/10/03 20:19:00]

this looks fishy..
wouldn't shutting down the whole process client break networkingPrivate function
calls?
the extension code could have something like this:

chrome.networkingPrivate.addObserver();
chrome.networkingPrivate.removeObserver();
chrome.networkingPrivate.getVisibleNetworks();

[mef, 2013/10/08 21:46:26]

I agree, however I've been told that this is the only indication of the
extension lifespan.
I'll be glad to use something else if it exists. 

Luckily this will not break consecutive calls as they will just start a new
instance of Utility Process.

[tbarzic, 2013/10/10 20:58:39]

Can it break API calls (possibly from another extension) that are in progress
when the client is shutdown?
Also, if an API function is called after all observers have been removed, the
process_client may not shutdown before Chrome exit.

[mef, 2013/10/11 22:16:29]

It shouldn't break networking Private API calls, even from another extension,
and I believe that it gets its own designated instance of Utility Process.

[tbarzic, 2013/10/12 02:14:09]

wait, isn't NetworkingPrivateProcessClient reused inside the same profile (and
thus also the utility process since the process client has exactly on utility
process)?
It looks as if you're using
NetworkingPrivateProcessClient::GetProcessClientForProfile(profile_) everywhere
you need the utility process. 

I was thinking about the following (actually we could have the same race with
extension A == extension B):
extension A adds a listener for networkListChanged
extension B calls getVisibleNetworks (doesn't receive callback yet)
extension A removes the listener for networkListChanged (and thus shuts down the
NetworkPrivateProcessClient) before visible networks requested by extension B
are calculated by the utility process.

Would extension B get a callback getVisibleNetworks (as the process client is
shutdown and its utility_process_host_ is reset).

+  }
+
+  listening_ = should_listen;
+}
+
+}  // namespace extensions