extensions/browser/api/networking_private/networking_private_delegate.h

   1 // Copyright 2014 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 EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_
   6 #define EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_
   7
   8 #include <string>
   9
  10 #include "base/callback.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/values.h"
  13 #include "components/keyed_service/core/keyed_service.h"
  14
  15 namespace content {
  16 class BrowserContext;
  17 }
  18
  19 namespace extensions {
  20
  21 class NetworkingPrivateDelegateObserver;
  22
  23 namespace core_api {
  24 namespace networking_private {
  25 struct VerificationProperties;
  26 }  // networking_private
  27 }  // core_api
  28
  29 // Base class for platform dependent networkingPrivate API implementations.
  30 // All inputs and results for this class use ONC values. See
  31 // networking_private.json for descriptions of the expected inputs and results.
  32 class NetworkingPrivateDelegate : public KeyedService {
  33  public:
  34   typedef base::Callback<void(scoped_ptr<base::DictionaryValue>)>
  35       DictionaryCallback;
  36   typedef base::Callback<void()> VoidCallback;
  37   typedef base::Callback<void(bool)> BoolCallback;
  38   typedef base::Callback<void(const std::string&)> StringCallback;
  39   typedef base::Callback<void(scoped_ptr<base::ListValue>)> NetworkListCallback;
  40   typedef base::Callback<void(const std::string&)> FailureCallback;
  41   typedef core_api::networking_private::VerificationProperties
  42       VerificationProperties;
  43
  44   // The Verify* methods will be forwarded to a delegate implementation if
  45   // provided, otherwise they will fail. A separate delegate it used so that the
  46   // current Verify* implementations are not exposed outside of src/chrome.
  47   class VerifyDelegate {
  48    public:
  49     typedef NetworkingPrivateDelegate::VerificationProperties
  50         VerificationProperties;
  51     typedef NetworkingPrivateDelegate::BoolCallback BoolCallback;
  52     typedef NetworkingPrivateDelegate::StringCallback StringCallback;
  53     typedef NetworkingPrivateDelegate::FailureCallback FailureCallback;
  54
  55     VerifyDelegate();
  56     virtual ~VerifyDelegate();
  57
  58     virtual void VerifyDestination(
  59         const VerificationProperties& verification_properties,
  60         const BoolCallback& success_callback,
  61         const FailureCallback& failure_callback) = 0;
  62     virtual void VerifyAndEncryptCredentials(
  63         const std::string& guid,
  64         const VerificationProperties& verification_properties,
  65         const StringCallback& success_callback,
  66         const FailureCallback& failure_callback) = 0;
  67     virtual void VerifyAndEncryptData(
  68         const VerificationProperties& verification_properties,
  69         const std::string& data,
  70         const StringCallback& success_callback,
  71         const FailureCallback& failure_callback) = 0;
  72
  73    private:
  74     DISALLOW_COPY_AND_ASSIGN(VerifyDelegate);
  75   };
  76
  77   // If |verify_delegate| is not NULL, the Verify* methods will be forwarded
  78   // to the delegate. Otherwise they will fail with a NotSupported error.
  79   explicit NetworkingPrivateDelegate(
  80       scoped_ptr<VerifyDelegate> verify_delegate);
  81   ~NetworkingPrivateDelegate() override;
  82
  83   // Asynchronous methods
  84   virtual void GetProperties(const std::string& guid,
  85                              const DictionaryCallback& success_callback,
  86                              const FailureCallback& failure_callback) = 0;
  87   virtual void GetManagedProperties(
  88       const std::string& guid,
  89       const DictionaryCallback& success_callback,
  90       const FailureCallback& failure_callback) = 0;
  91   virtual void GetState(const std::string& guid,
  92                         const DictionaryCallback& success_callback,
  93                         const FailureCallback& failure_callback) = 0;
  94   virtual void SetProperties(const std::string& guid,
  95                              scoped_ptr<base::DictionaryValue> properties,
  96                              const VoidCallback& success_callback,
  97                              const FailureCallback& failure_callback) = 0;
  98   virtual void CreateNetwork(bool shared,
  99                              scoped_ptr<base::DictionaryValue> properties,
 100                              const StringCallback& success_callback,
 101                              const FailureCallback& failure_callback) = 0;
 102   virtual void GetNetworks(const std::string& network_type,
 103                            bool configured_only,
 104                            bool visible_only,
 105                            int limit,
 106                            const NetworkListCallback& success_callback,
 107                            const FailureCallback& failure_callback) = 0;
 108   virtual void StartConnect(const std::string& guid,
 109                             const VoidCallback& success_callback,
 110                             const FailureCallback& failure_callback) = 0;
 111   virtual void StartDisconnect(const std::string& guid,
 112                                const VoidCallback& success_callback,
 113                                const FailureCallback& failure_callback) = 0;
 114   virtual void SetWifiTDLSEnabledState(
 115       const std::string& ip_or_mac_address,
 116       bool enabled,
 117       const StringCallback& success_callback,
 118       const FailureCallback& failure_callback) = 0;
 119   virtual void GetWifiTDLSStatus(const std::string& ip_or_mac_address,
 120                                  const StringCallback& success_callback,
 121                                  const FailureCallback& failure_callback) = 0;
 122   virtual void GetCaptivePortalStatus(
 123       const std::string& guid,
 124       const StringCallback& success_callback,
 125       const FailureCallback& failure_callback) = 0;
 126
 127   // Synchronous methods
 128
 129   // Returns a list of ONC type strings.
 130   virtual scoped_ptr<base::ListValue> GetEnabledNetworkTypes() = 0;
 131
 132   // Returns true if the ONC network type |type| is enabled.
 133   virtual bool EnableNetworkType(const std::string& type) = 0;
 134
 135   // Returns true if the ONC network type |type| is disabled.
 136   virtual bool DisableNetworkType(const std::string& type) = 0;
 137
 138   // Returns true if a scan was requested. It may take many seconds for a scan
 139   // to complete. The scan may or may not trigger API events when complete.
 140   virtual bool RequestScan() = 0;
 141
 142   // Optional methods for adding a NetworkingPrivateDelegateObserver for
 143   // implementations that require it (non-chromeos).
 144   virtual void AddObserver(NetworkingPrivateDelegateObserver* observer);
 145   virtual void RemoveObserver(NetworkingPrivateDelegateObserver* observer);
 146
 147   // Verify* methods are forwarded to |verify_delegate_| if not NULL.
 148   void VerifyDestination(const VerificationProperties& verification_properties,
 149                          const BoolCallback& success_callback,
 150                          const FailureCallback& failure_callback);
 151   void VerifyAndEncryptCredentials(
 152       const std::string& guid,
 153       const VerificationProperties& verification_properties,
 154       const StringCallback& success_callback,
 155       const FailureCallback& failure_callback);
 156   void VerifyAndEncryptData(
 157       const VerificationProperties& verification_properties,
 158       const std::string& data,
 159       const StringCallback& success_callback,
 160       const FailureCallback& failure_callback);
 161
 162  private:
 163   // Interface for Verify* methods. May be NULL.
 164   scoped_ptr<VerifyDelegate> verify_delegate_;
 165
 166   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateDelegate);
 167 };
 168
 169 }  // namespace extensions
 170
 171 #endif  // EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_