src/chrome/browser/extensions/api/networking_private/networking_private_event_router_nonchromeos.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 "chrome/browser/extensions/api/networking_private/networking_private_api.h"
   8 #include "chrome/browser/extensions/api/networking_private/networking_private_service_client.h"
   9 #include "chrome/browser/extensions/api/networking_private/networking_private_service_client_factory.h"
  10 #include "chrome/browser/extensions/extension_system.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/common/extensions/api/networking_private.h"
  13
  14 namespace extensions {
  15
  16 // This is an event router that will observe listeners to |NetworksChanged| and
  17 // |NetworkListChanged| events.
  18 class NetworkingPrivateEventRouterImpl
  19     : public NetworkingPrivateEventRouter,
  20       NetworkingPrivateServiceClient::Observer {
  21  public:
  22   explicit NetworkingPrivateEventRouterImpl(Profile* profile);
  23   virtual ~NetworkingPrivateEventRouterImpl();
  24
  25  protected:
  26   // BrowserContextKeyedService overrides:
  27   virtual void Shutdown() OVERRIDE;
  28
  29   // EventRouter::Observer overrides:
  30   virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
  31   virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
  32
  33   // NetworkingPrivateServiceClient::Observer overrides:
  34   virtual void OnNetworksChangedEvent(
  35       const std::vector<std::string>& network_guids) OVERRIDE;
  36   virtual void OnNetworkListChangedEvent(
  37       const std::vector<std::string>& network_guids) OVERRIDE;
  38
  39  private:
  40   // Decide if we should listen for network changes or not. If there are any
  41   // JavaScript listeners registered for the onNetworkChanged event, then we
  42   // want to register for change notification from the network state handler.
  43   // Otherwise, we want to unregister and not be listening to network changes.
  44   void StartOrStopListeningForNetworkChanges();
  45
  46   Profile* profile_;
  47   bool listening_;
  48
  49   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateEventRouterImpl);
  50 };
  51
  52 NetworkingPrivateEventRouterImpl::NetworkingPrivateEventRouterImpl(
  53     Profile* profile)
  54     : profile_(profile), listening_(false) {
  55   // Register with the event router so we know when renderers are listening to
  56   // our events. We first check and see if there *is* an event router, because
  57   // some unit tests try to create all profile services, but don't initialize
  58   // the event router first.
  59   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
  60   if (!event_router)
  61     return;
  62   event_router->RegisterObserver(
  63       this, api::networking_private::OnNetworksChanged::kEventName);
  64   event_router->RegisterObserver(
  65       this, api::networking_private::OnNetworkListChanged::kEventName);
  66   StartOrStopListeningForNetworkChanges();
  67 }
  68
  69 NetworkingPrivateEventRouterImpl::~NetworkingPrivateEventRouterImpl() {
  70   DCHECK(!listening_);
  71 }
  72
  73 void NetworkingPrivateEventRouterImpl::Shutdown() {
  74   // Unregister with the event router. We first check and see if there *is* an
  75   // event router, because some unit tests try to shutdown all profile services,
  76   // but didn't initialize the event router first.
  77   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
  78   if (event_router)
  79     event_router->UnregisterObserver(this);
  80
  81   if (!listening_)
  82     return;
  83   listening_ = false;
  84   NetworkingPrivateServiceClient* process_client =
  85       NetworkingPrivateServiceClientFactory::GetForProfile(profile_);
  86   process_client->RemoveObserver(this);
  87 }
  88
  89 void NetworkingPrivateEventRouterImpl::OnListenerAdded(
  90     const EventListenerInfo& details) {
  91   // Start listening to events from the network state handler.
  92   StartOrStopListeningForNetworkChanges();
  93 }
  94
  95 void NetworkingPrivateEventRouterImpl::OnListenerRemoved(
  96     const EventListenerInfo& details) {
  97   // Stop listening to events from the network state handler if there are no
  98   // more listeners.
  99   StartOrStopListeningForNetworkChanges();
 100 }
 101
 102 void NetworkingPrivateEventRouterImpl::StartOrStopListeningForNetworkChanges() {
 103   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
 104   if (!event_router)
 105     return;
 106   bool should_listen =
 107       event_router->HasEventListener(
 108           api::networking_private::OnNetworksChanged::kEventName) ||
 109       event_router->HasEventListener(
 110           api::networking_private::OnNetworkListChanged::kEventName);
 111
 112   if (should_listen && !listening_) {
 113     NetworkingPrivateServiceClient* process_client =
 114         NetworkingPrivateServiceClientFactory::GetForProfile(profile_);
 115     process_client->AddObserver(this);
 116   }
 117
 118   if (!should_listen && listening_) {
 119     NetworkingPrivateServiceClient* process_client =
 120         NetworkingPrivateServiceClientFactory::GetForProfile(profile_);
 121     process_client->RemoveObserver(this);
 122   }
 123
 124   listening_ = should_listen;
 125 }
 126
 127 void NetworkingPrivateEventRouterImpl::OnNetworksChangedEvent(
 128     const std::vector<std::string>& network_guids) {
 129   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
 130   if (!event_router)
 131     return;
 132   scoped_ptr<base::ListValue> args(
 133       api::networking_private::OnNetworksChanged::Create(network_guids));
 134   scoped_ptr<extensions::Event> netchanged_event(new extensions::Event(
 135       api::networking_private::OnNetworksChanged::kEventName, args.Pass()));
 136   event_router->BroadcastEvent(netchanged_event.Pass());
 137 }
 138
 139 void NetworkingPrivateEventRouterImpl::OnNetworkListChangedEvent(
 140     const std::vector<std::string>& network_guids) {
 141   EventRouter* event_router = ExtensionSystem::Get(profile_)->event_router();
 142   if (!event_router)
 143     return;
 144   scoped_ptr<base::ListValue> args(
 145       api::networking_private::OnNetworkListChanged::Create(network_guids));
 146   scoped_ptr<extensions::Event> netlistchanged_event(new extensions::Event(
 147       api::networking_private::OnNetworkListChanged::kEventName,
 148       args.Pass()));
 149   event_router->BroadcastEvent(netlistchanged_event.Pass());
 150 }
 151
 152 NetworkingPrivateEventRouter* NetworkingPrivateEventRouter::Create(
 153     Profile* profile) {
 154   return new NetworkingPrivateEventRouterImpl(profile);
 155 }
 156
 157 }  // namespace extensions