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   void Shutdown() override;
 116
 117   // NetworkingPrivateDelegate
 118   void GetProperties(const std::string& guid,
 119                      const DictionaryCallback& success_callback,
 120                      const FailureCallback& failure_callback) override;
 121   void GetManagedProperties(const std::string& guid,
 122                             const DictionaryCallback& success_callback,
 123                             const FailureCallback& failure_callback) override;
 124   void GetState(const std::string& guid,
 125                 const DictionaryCallback& success_callback,
 126                 const FailureCallback& failure_callback) override;
 127   void SetProperties(const std::string& guid,
 128                      scoped_ptr<base::DictionaryValue> properties_dict,
 129                      const VoidCallback& success_callback,
 130                      const FailureCallback& failure_callback) override;
 131   void CreateNetwork(bool shared,
 132                      scoped_ptr<base::DictionaryValue> properties_dict,
 133                      const StringCallback& success_callback,
 134                      const FailureCallback& failure_callback) override;
 135   void GetNetworks(const std::string& network_type,
 136                    bool configured_only,
 137                    bool visible_only,
 138                    int limit,
 139                    const NetworkListCallback& success_callback,
 140                    const FailureCallback& failure_callback) override;
 141   void StartConnect(const std::string& guid,
 142                     const VoidCallback& success_callback,
 143                     const FailureCallback& failure_callback) override;
 144   void StartDisconnect(const std::string& guid,
 145                        const VoidCallback& success_callback,
 146                        const FailureCallback& failure_callback) override;
 147   void VerifyDestination(const VerificationProperties& verification_properties,
 148                          const BoolCallback& success_callback,
 149                          const FailureCallback& failure_callback) override;
 150   void VerifyAndEncryptCredentials(
 151       const std::string& guid,
 152       const VerificationProperties& verification_properties,
 153       const StringCallback& success_callback,
 154       const FailureCallback& failure_callback) override;
 155   void VerifyAndEncryptData(
 156       const VerificationProperties& verification_properties,
 157       const std::string& data,
 158       const StringCallback& success_callback,
 159       const FailureCallback& failure_callback) override;
 160   void SetWifiTDLSEnabledState(
 161       const std::string& ip_or_mac_address,
 162       bool enabled,
 163       const StringCallback& success_callback,
 164       const FailureCallback& failure_callback) override;
 165   void GetWifiTDLSStatus(const std::string& ip_or_mac_address,
 166                          const StringCallback& success_callback,
 167                          const FailureCallback& failure_callback) override;
 168   void GetCaptivePortalStatus(const std::string& guid,
 169                               const StringCallback& success_callback,
 170                               const FailureCallback& failure_callback) override;
 171   scoped_ptr<base::ListValue> GetEnabledNetworkTypes() override;
 172   bool EnableNetworkType(const std::string& type) override;
 173   bool DisableNetworkType(const std::string& type) override;
 174   bool RequestScan() override;
 175
 176   // Adds observer to network events.
 177   void AddObserver(Observer* network_events_observer);
 178
 179   // Removes observer to network events. If there is no observers,
 180   // then process can be shut down when there are no more calls pending return.
 181   void RemoveObserver(Observer* network_events_observer);
 182
 183   // NetworkChangeNotifier::NetworkChangeObserver implementation.
 184   void OnNetworkChanged(
 185       net::NetworkChangeNotifier::ConnectionType type) override;
 186
 187  private:
 188   // Callbacks to extension api function objects. Keep reference to API object
 189   // and are released in ShutdownOnUIThread. Run when WiFiService calls back
 190   // into NetworkingPrivateServiceClient's callback wrappers.
 191   typedef int32 ServiceCallbacksID;
 192   struct ServiceCallbacks {
 193     ServiceCallbacks();
 194     ~ServiceCallbacks();
 195
 196     DictionaryCallback get_properties_callback;
 197     VoidCallback start_connect_callback;
 198     VoidCallback start_disconnect_callback;
 199     VoidCallback set_properties_callback;
 200     StringCallback create_network_callback;
 201     NetworkListCallback get_visible_networks_callback;
 202     FailureCallback failure_callback;
 203
 204     BoolCallback verify_destination_callback;
 205     StringCallback verify_and_encrypt_data_callback;
 206     StringCallback verify_and_encrypt_credentials_callback;
 207
 208     ServiceCallbacksID id;
 209   };
 210   typedef IDMap<ServiceCallbacks, IDMapOwnPointer> ServiceCallbacksMap;
 211
 212   ~NetworkingPrivateServiceClient() override;
 213
 214   // Callback wrappers.
 215   void AfterGetProperties(ServiceCallbacksID callback_id,
 216                           const std::string& network_guid,
 217                           scoped_ptr<base::DictionaryValue> properties,
 218                           const std::string* error);
 219   void AfterSetProperties(ServiceCallbacksID callback_id,
 220                           const std::string* error);
 221   void AfterCreateNetwork(ServiceCallbacksID callback_id,
 222                           const std::string* network_guid,
 223                           const std::string* error);
 224   void AfterGetVisibleNetworks(ServiceCallbacksID callback_id,
 225                                scoped_ptr<base::ListValue> networks);
 226   void AfterStartConnect(ServiceCallbacksID callback_id,
 227                          const std::string* error);
 228   void AfterStartDisconnect(ServiceCallbacksID callback_id,
 229                             const std::string* error);
 230   void AfterVerifyDestination(ServiceCallbacksID callback_id,
 231                               const bool* result,
 232                               const std::string* error);
 233   void AfterVerifyAndEncryptData(ServiceCallbacksID callback_id,
 234                                  const std::string* result,
 235                                  const std::string* error);
 236   void AfterVerifyAndEncryptCredentials(ServiceCallbacksID callback_id,
 237                                         const std::string& encrypted_data,
 238                                         const std::string& error);
 239
 240   void OnNetworksChangedEventOnUIThread(
 241       const WiFiService::NetworkGuidList& network_guid_list);
 242   void OnNetworkListChangedEventOnUIThread(
 243       const WiFiService::NetworkGuidList& network_guid_list);
 244
 245   // Add new |ServiceCallbacks| to |callbacks_map_|.
 246   ServiceCallbacks* AddServiceCallbacks();
 247   // Removes ServiceCallbacks for |callback_id| from |callbacks_map_|.
 248   void RemoveServiceCallbacks(ServiceCallbacksID callback_id);
 249
 250   // Callbacks to run when callback is called from WiFiService.
 251   ServiceCallbacksMap callbacks_map_;
 252   // Observers to Network Events.
 253   ObserverList<Observer> network_events_observers_;
 254   // Interface for Verify* methods. Used and deleted on the worker thread.
 255   // May be NULL.
 256   scoped_ptr<CryptoVerify> crypto_verify_;
 257   // Interface to WiFiService. Used and deleted on the worker thread.
 258   scoped_ptr<wifi::WiFiService> wifi_service_;
 259   // Sequence token associated with wifi tasks.
 260   base::SequencedWorkerPool::SequenceToken sequence_token_;
 261   // Task runner for worker tasks.
 262   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 263   // Use WeakPtrs for callbacks from |wifi_service_| and |crypto_verify_|.
 264   base::WeakPtrFactory<NetworkingPrivateServiceClient> weak_factory_;
 265
 266   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateServiceClient);
 267 };
 268
 269 }  // namespace extensions
 270
 271 #endif  // CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_SERVICE_CLIENT_H_