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