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

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/networking_private/networking_private_event_router.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "chrome/browser/browser_process.h"
   9 #include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
  10 #include "chrome/browser/extensions/event_router_forwarder.h"
  11 #include "chrome/browser/extensions/extension_system.h"
  12 #include "chrome/browser/extensions/extension_system_factory.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/common/extensions/api/networking_private.h"
  15 #include "chromeos/network/network_event_log.h"
  16 #include "chromeos/network/network_state.h"
  17 #include "chromeos/network/network_state_handler.h"
  18 #include "chromeos/network/onc/onc_signature.h"
  19 #include "chromeos/network/onc/onc_translator.h"
  20 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
  21 #include "components/onc/onc_constants.h"
  22 #include "third_party/cros_system_api/dbus/service_constants.h"
  23
  24 using extensions::EventRouter;
  25 using extensions::ExtensionSystem;
  26 namespace api = extensions::api::networking_private;
  27
  28 namespace chromeos {
  29
  30 NetworkingPrivateEventRouter::NetworkingPrivateEventRouter(Profile* profile)
  31     : profile_(profile), listening_(false) {
  32   // Register with the event router so we know when renderers are listening to
  33   // our events. We first check and see if there *is* an event router, because
  34   // some unit tests try to create all profile services, but don't initialize
  35   // the event router first.
  36   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
  37   if (event_router) {
  38     event_router->RegisterObserver(
  39         this, api::OnNetworksChanged::kEventName);
  40     event_router->RegisterObserver(
  41         this, api::OnNetworkListChanged::kEventName);
  42     StartOrStopListeningForNetworkChanges();
  43   }
  44 }
  45
  46 NetworkingPrivateEventRouter::~NetworkingPrivateEventRouter() {
  47   DCHECK(!listening_);
  48 }
  49
  50 void NetworkingPrivateEventRouter::Shutdown() {
  51   // Unregister with the event router. We first check and see if there *is* an
  52   // event router, because some unit tests try to shutdown all profile services,
  53   // but didn't initialize the event router first.
  54   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
  55   if (event_router)
  56     event_router->UnregisterObserver(this);
  57
  58   if (listening_) {
  59     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
  60         this, FROM_HERE);
  61   }
  62   listening_ = false;
  63 }
  64
  65 void NetworkingPrivateEventRouter::OnListenerAdded(
  66     const extensions::EventListenerInfo& details) {
  67   // Start listening to events from the network state handler.
  68   StartOrStopListeningForNetworkChanges();
  69 }
  70
  71 void NetworkingPrivateEventRouter::OnListenerRemoved(
  72     const extensions::EventListenerInfo& details) {
  73   // Stop listening to events from the network state handler if there are no
  74   // more listeners.
  75   StartOrStopListeningForNetworkChanges();
  76 }
  77
  78 void NetworkingPrivateEventRouter::StartOrStopListeningForNetworkChanges() {
  79   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
  80   bool should_listen =
  81       event_router->HasEventListener(api::OnNetworksChanged::kEventName) ||
  82       event_router->HasEventListener(api::OnNetworkListChanged::kEventName);
  83
  84   if (should_listen && !listening_) {
  85     NetworkHandler::Get()->network_state_handler()->AddObserver(
  86         this, FROM_HERE);
  87   } else if (!should_listen && listening_) {
  88     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
  89         this, FROM_HERE);
  90   }
  91   listening_ = should_listen;
  92 }
  93
  94 void NetworkingPrivateEventRouter::NetworkListChanged() {
  95   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
  96   NetworkStateHandler::NetworkStateList networks;
  97   NetworkHandler::Get()->network_state_handler()->GetNetworkList(&networks);
  98   if (!event_router->HasEventListener(api::OnNetworkListChanged::kEventName)) {
  99     // TODO(stevenjb): Remove logging once crbug.com/256881 is fixed
 100     // (or at least reduce to LOG_DEBUG). Same with NET_LOG events below.
 101     NET_LOG_EVENT("NetworkingPrivate.NetworkListChanged: No Listeners", "");
 102     return;
 103   }
 104
 105   NET_LOG_EVENT("NetworkingPrivate.NetworkListChanged", "");
 106
 107   std::vector<std::string> changes;
 108   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
 109            networks.begin(); iter != networks.end(); ++iter) {
 110     // TODO(gspencer): Currently the "GUID" is actually the service path. Fix
 111     // this to be the real GUID once we're using
 112     // ManagedNetworkConfigurationManager.
 113     changes.push_back((*iter)->path());
 114   }
 115
 116   scoped_ptr<base::ListValue> args(api::OnNetworkListChanged::Create(changes));
 117   scoped_ptr<extensions::Event> extension_event(new extensions::Event(
 118       api::OnNetworkListChanged::kEventName, args.Pass()));
 119   event_router->BroadcastEvent(extension_event.Pass());
 120 }
 121
 122 void NetworkingPrivateEventRouter::NetworkPropertiesUpdated(
 123     const NetworkState* network) {
 124   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
 125   if (!event_router->HasEventListener(api::OnNetworksChanged::kEventName)) {
 126     NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated: No Listeners",
 127                   network->path());
 128     return;
 129   }
 130   NET_LOG_EVENT("NetworkingPrivate.NetworkPropertiesUpdated",
 131                 network->path());
 132   scoped_ptr<base::ListValue> args(api::OnNetworksChanged::Create(
 133       std::vector<std::string>(1, network->path())));
 134   scoped_ptr<extensions::Event> extension_event(
 135       new extensions::Event(api::OnNetworksChanged::kEventName, args.Pass()));
 136   event_router->BroadcastEvent(extension_event.Pass());
 137 }
 138
 139 }  // namespace chromeos
 140