src/chrome/browser/extensions/api/networking_private/networking_private_service_client.h

   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 #ifndef CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_SERVICE_CLIENT_H_
   6 #define CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_SERVICE_CLIENT_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/id_map.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/observer_list.h"
  16 #include "base/strings/string16.h"
  17 #include "base/supports_user_data.h"
  18 #include "base/threading/sequenced_worker_pool.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
  21 #include "components/keyed_service/core/keyed_service.h"
  22 #include "components/wifi/wifi_service.h"
  23 #include "content/public/browser/utility_process_host.h"
  24 #include "content/public/browser/utility_process_host_client.h"
  25 #include "net/base/network_change_notifier.h"
  26
  27 namespace base {
  28 class SequencedTaskRunner;
  29 }
  30
  31 namespace wifi {
  32 class WiFiService;
  33 }
  34
  35 namespace extensions {
  36
  37 using wifi::WiFiService;
  38
  39 // Windows / Mac NetworkingPrivateApi implementation. This implements
  40 // WiFiService and CryptoVerify interfaces and invokes them on the worker
  41 // thread. Observes |OnNetworkChanged| notifications and posts them to
  42 // WiFiService on the worker thread to |UpdateConnectedNetwork|. Created and
  43 // called from the UI thread.
  44 class NetworkingPrivateServiceClient
  45     : public KeyedService,
  46       public NetworkingPrivateDelegate,
  47       net::NetworkChangeNotifier::NetworkChangeObserver {
  48  public:
  49   // Interface for Verify* methods implementation.
  50   class CryptoVerify {
  51    public:
  52     typedef base::Callback<
  53         void(const std::string& key_data, const std::string& error)>
  54         VerifyAndEncryptCredentialsCallback;
  55
  56     // TODO(stevenjb): Remove this when addressing crbug.com/394481
  57     struct Credentials {
  58       Credentials();
  59       ~Credentials();
  60       std::string certificate;
  61       std::string signed_data;
  62       std::string unsigned_data;
  63       std::string device_bssid;
  64       std::string public_key;
  65     };
  66
  67     CryptoVerify();
  68     virtual ~CryptoVerify();
  69
  70     // Must be provided by the implementation. May return NULL if certificate
  71     // verification is unavailable, see NetworkingPrivateServiceClient().
  72     static CryptoVerify* Create();
  73
  74     virtual void VerifyDestination(const Credentials& credentials,
  75                                    bool* verified,
  76                                    std::string* error) = 0;
  77
  78     virtual void VerifyAndEncryptCredentials(
  79         const std::string& network_guid,
  80         const Credentials& credentials,
  81         const VerifyAndEncryptCredentialsCallback& callback) = 0;
  82
  83     virtual void VerifyAndEncryptData(const Credentials& credentials,
  84                                       const std::string& data,
  85                                       std::string* base64_encoded_ciphertext,
  86                                       std::string* error) = 0;
  87
  88    private:
  89     DISALLOW_COPY_AND_ASSIGN(CryptoVerify);
  90   };
  91
  92   // Interface for observing Network Events.
  93   class Observer {
  94    public:
  95     Observer() {}
  96     virtual ~Observer() {}
  97
  98     virtual void OnNetworksChangedEvent(
  99         const std::vector<std::string>& network_guids) = 0;
 100     virtual void OnNetworkListChangedEvent(
 101         const std::vector<std::string>& network_guids) = 0;
 102
 103    private:
 104     DISALLOW_COPY_AND_ASSIGN(Observer);
 105   };
 106
 107   // Takes ownership of |wifi_service| and |crypto_verify|. They are accessed
 108   // and deleted on the worker thread. The deletion task is posted during the
 109   // NetworkingPrivateServiceClient shutdown. |crypto_verify| may be NULL in
 110   // which case Verify* will return a 'not implemented' error.
 111   NetworkingPrivateServiceClient(wifi::WiFiService* wifi_service,
 112                                  CryptoVerify* crypto_verify);
 113
 114   // KeyedService
 115   virtual void Shutdown() OVERRIDE;
 116
 117   // NetworkingPrivateDelegate
 118   virtual void GetProperties(const std::string& guid,
 119                              const DictionaryCallback& success_callback,
 120                              const FailureCallback& failure_callback) OVERRIDE;
 121   virtual void GetManagedProperties(
 122       const std::string& guid,
 123       const DictionaryCallback& success_callback,
 124       const FailureCallback& failure_callback) OVERRIDE;
 125   virtual void GetState(const std::string& guid,
 126                         const DictionaryCallback& success_callback,
 127                         const FailureCallback& failure_callback) OVERRIDE;
 128   virtual void SetProperties(const std::string& guid,
 129                              scoped_ptr<base::DictionaryValue> properties_dict,
 130                              const VoidCallback& success_callback,
 131                              const FailureCallback& failure_callback) OVERRIDE;
 132   virtual void CreateNetwork(bool shared,
 133                              scoped_ptr<base::DictionaryValue> properties_dict,
 134                              const StringCallback& success_callback,
 135                              const FailureCallback& failure_callback) OVERRIDE;
 136   virtual void GetNetworks(const std::string& network_type,
 137                            bool configured_only,
 138                            bool visible_only,
 139                            int limit,
 140                            const NetworkListCallback& success_callback,
 141                            const FailureCallback& failure_callback) OVERRIDE;
 142   virtual void StartConnect(const std::string& guid,
 143                             const VoidCallback& success_callback,
 144                             const FailureCallback& failure_callback) OVERRIDE;
 145   virtual void StartDisconnect(
 146       const std::string& guid,
 147       const VoidCallback& success_callback,
 148       const FailureCallback& failure_callback) OVERRIDE;
 149   virtual void VerifyDestination(
 150       const VerificationProperties& verification_properties,
 151       const BoolCallback& success_callback,
 152       const FailureCallback& failure_callback) OVERRIDE;
 153   virtual void VerifyAndEncryptCredentials(
 154       const std::string& guid,
 155       const VerificationProperties& verification_properties,
 156       const StringCallback& success_callback,
 157       const FailureCallback& failure_callback) OVERRIDE;
 158   virtual void VerifyAndEncryptData(
 159       const VerificationProperties& verification_properties,
 160       const std::string& data,
 161       const StringCallback& success_callback,
 162       const FailureCallback& failure_callback) OVERRIDE;
 163   virtual void SetWifiTDLSEnabledState(
 164       const std::string& ip_or_mac_address,
 165       bool enabled,
 166       const StringCallback& success_callback,
 167       const FailureCallback& failure_callback) OVERRIDE;
 168   virtual void GetWifiTDLSStatus(
 169       const std::string& ip_or_mac_address,
 170       const StringCallback& success_callback,
 171       const FailureCallback& failure_callback) OVERRIDE;
 172   virtual void GetCaptivePortalStatus(
 173       const std::string& guid,
 174       const StringCallback& success_callback,
 175       const FailureCallback& failure_callback) OVERRIDE;
 176   virtual scoped_ptr<base::ListValue> GetEnabledNetworkTypes() OVERRIDE;
 177   virtual bool EnableNetworkType(const std::string& type) OVERRIDE;
 178   virtual bool DisableNetworkType(const std::string& type) OVERRIDE;
 179   virtual bool RequestScan() OVERRIDE;
 180
 181   // Adds observer to network events.
 182   void AddObserver(Observer* network_events_observer);
 183
 184   // Removes observer to network events. If there is no observers,
 185   // then process can be shut down when there are no more calls pending return.
 186   void RemoveObserver(Observer* network_events_observer);
 187
 188   // NetworkChangeNotifier::NetworkChangeObserver implementation.
 189   virtual void OnNetworkChanged(
 190       net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
 191
 192  private:
 193   // Callbacks to extension api function objects. Keep reference to API object
 194   // and are released in ShutdownOnUIThread. Run when WiFiService calls back
 195   // into NetworkingPrivateServiceClient's callback wrappers.
 196   typedef int32 ServiceCallbacksID;
 197   struct ServiceCallbacks {
 198     ServiceCallbacks();
 199     ~ServiceCallbacks();
 200
 201     DictionaryCallback get_properties_callback;
 202     VoidCallback start_connect_callback;
 203     VoidCallback start_disconnect_callback;
 204     VoidCallback set_properties_callback;
 205     StringCallback create_network_callback;
 206     NetworkListCallback get_visible_networks_callback;
 207     FailureCallback failure_callback;
 208
 209     BoolCallback verify_destination_callback;
 210     StringCallback verify_and_encrypt_data_callback;
 211     StringCallback verify_and_encrypt_credentials_callback;
 212
 213     ServiceCallbacksID id;
 214   };
 215   typedef IDMap<ServiceCallbacks, IDMapOwnPointer> ServiceCallbacksMap;
 216
 217   virtual ~NetworkingPrivateServiceClient();
 218
 219   // Callback wrappers.
 220   void AfterGetProperties(ServiceCallbacksID callback_id,
 221                           const std::string& network_guid,
 222                           scoped_ptr<base::DictionaryValue> properties,
 223                           const std::string* error);
 224   void AfterSetProperties(ServiceCallbacksID callback_id,
 225                           const std::string* error);
 226   void AfterCreateNetwork(ServiceCallbacksID callback_id,
 227                           const std::string* network_guid,
 228                           const std::string* error);
 229   void AfterGetVisibleNetworks(ServiceCallbacksID callback_id,
 230                                scoped_ptr<base::ListValue> networks);
 231   void AfterStartConnect(ServiceCallbacksID callback_id,
 232                          const std::string* error);
 233   void AfterStartDisconnect(ServiceCallbacksID callback_id,
 234                             const std::string* error);
 235   void AfterVerifyDestination(ServiceCallbacksID callback_id,
 236                               const bool* result,
 237                               const std::string* error);
 238   void AfterVerifyAndEncryptData(ServiceCallbacksID callback_id,
 239                                  const std::string* result,
 240                                  const std::string* error);
 241   void AfterVerifyAndEncryptCredentials(ServiceCallbacksID callback_id,
 242                                         const std::string& encrypted_data,
 243                                         const std::string& error);
 244
 245   void OnNetworksChangedEventOnUIThread(
 246       const WiFiService::NetworkGuidList& network_guid_list);
 247   void OnNetworkListChangedEventOnUIThread(
 248       const WiFiService::NetworkGuidList& network_guid_list);
 249
 250   // Add new |ServiceCallbacks| to |callbacks_map_|.
 251   ServiceCallbacks* AddServiceCallbacks();
 252   // Removes ServiceCallbacks for |callback_id| from |callbacks_map_|.
 253   void RemoveServiceCallbacks(ServiceCallbacksID callback_id);
 254
 255   // Callbacks to run when callback is called from WiFiService.
 256   ServiceCallbacksMap callbacks_map_;
 257   // Observers to Network Events.
 258   ObserverList<Observer> network_events_observers_;
 259   // Interface for Verify* methods. Used and deleted on the worker thread.
 260   // May be NULL.
 261   scoped_ptr<CryptoVerify> crypto_verify_;
 262   // Interface to WiFiService. Used and deleted on the worker thread.
 263   scoped_ptr<wifi::WiFiService> wifi_service_;
 264   // Sequence token associated with wifi tasks.
 265   base::SequencedWorkerPool::SequenceToken sequence_token_;
 266   // Task runner for worker tasks.
 267   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 268   // Use WeakPtrs for callbacks from |wifi_service_| and |crypto_verify_|.
 269   base::WeakPtrFactory<NetworkingPrivateServiceClient> weak_factory_;
 270
 271   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateServiceClient);
 272 };
 273
 274 }  // namespace extensions
 275
 276 #endif  // CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_SERVICE_CLIENT_H_