extensions/browser/api/networking_private/networking_private_api.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 EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_API_H_
   6 #define EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_API_H_
   7
   8 #include <string>
   9
  10 #include "base/macros.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/values.h"
  13 #include "extensions/browser/extension_function.h"
  14
  15 namespace extensions {
  16
  17 namespace networking_private {
  18
  19 extern const char kErrorInvalidNetworkGuid[];
  20 extern const char kErrorNetworkUnavailable[];
  21 extern const char kErrorEncryptionError[];
  22 extern const char kErrorNotReady[];
  23 extern const char kErrorNotSupported[];
  24
  25 }  // namespace networking_private
  26
  27 // Implements the chrome.networkingPrivate.getProperties method.
  28 class NetworkingPrivateGetPropertiesFunction : public AsyncExtensionFunction {
  29  public:
  30   NetworkingPrivateGetPropertiesFunction() {}
  31   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getProperties",
  32                              NETWORKINGPRIVATE_GETPROPERTIES);
  33
  34  protected:
  35   ~NetworkingPrivateGetPropertiesFunction() override;
  36
  37   // AsyncExtensionFunction overrides.
  38   bool RunAsync() override;
  39
  40  private:
  41   void Success(scoped_ptr<base::DictionaryValue> result);
  42   void Failure(const std::string& error_name);
  43
  44   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetPropertiesFunction);
  45 };
  46
  47 // Implements the chrome.networkingPrivate.getManagedProperties method.
  48 class NetworkingPrivateGetManagedPropertiesFunction
  49     : public AsyncExtensionFunction {
  50  public:
  51   NetworkingPrivateGetManagedPropertiesFunction() {}
  52   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getManagedProperties",
  53                              NETWORKINGPRIVATE_GETMANAGEDPROPERTIES);
  54
  55  protected:
  56   ~NetworkingPrivateGetManagedPropertiesFunction() override;
  57
  58   // AsyncExtensionFunction overrides.
  59   bool RunAsync() override;
  60
  61  private:
  62   void Success(scoped_ptr<base::DictionaryValue> result);
  63   void Failure(const std::string& error);
  64
  65   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetManagedPropertiesFunction);
  66 };
  67
  68 // Implements the chrome.networkingPrivate.getState method.
  69 class NetworkingPrivateGetStateFunction : public AsyncExtensionFunction {
  70  public:
  71   NetworkingPrivateGetStateFunction() {}
  72   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getState",
  73                              NETWORKINGPRIVATE_GETSTATE);
  74
  75  protected:
  76   ~NetworkingPrivateGetStateFunction() override;
  77
  78   // AsyncExtensionFunction overrides.
  79   bool RunAsync() override;
  80
  81  private:
  82   void Success(scoped_ptr<base::DictionaryValue> result);
  83   void Failure(const std::string& error);
  84
  85   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetStateFunction);
  86 };
  87
  88 // Implements the chrome.networkingPrivate.setProperties method.
  89 class NetworkingPrivateSetPropertiesFunction : public AsyncExtensionFunction {
  90  public:
  91   NetworkingPrivateSetPropertiesFunction() {}
  92   DECLARE_EXTENSION_FUNCTION("networkingPrivate.setProperties",
  93                              NETWORKINGPRIVATE_SETPROPERTIES);
  94
  95  protected:
  96   ~NetworkingPrivateSetPropertiesFunction() override;
  97
  98   // AsyncExtensionFunction overrides.
  99   bool RunAsync() override;
 100
 101  private:
 102   void Success();
 103   void Failure(const std::string& error);
 104
 105   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateSetPropertiesFunction);
 106 };
 107
 108 // Implements the chrome.networkingPrivate.createNetwork method.
 109 class NetworkingPrivateCreateNetworkFunction : public AsyncExtensionFunction {
 110  public:
 111   NetworkingPrivateCreateNetworkFunction() {}
 112   DECLARE_EXTENSION_FUNCTION("networkingPrivate.createNetwork",
 113                              NETWORKINGPRIVATE_CREATENETWORK);
 114
 115  protected:
 116   ~NetworkingPrivateCreateNetworkFunction() override;
 117
 118   // AsyncExtensionFunction overrides.
 119   bool RunAsync() override;
 120
 121  private:
 122   void Success(const std::string& guid);
 123   void Failure(const std::string& error);
 124
 125   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCreateNetworkFunction);
 126 };
 127
 128 // Implements the chrome.networkingPrivate.getNetworks method.
 129 class NetworkingPrivateGetNetworksFunction : public AsyncExtensionFunction {
 130  public:
 131   NetworkingPrivateGetNetworksFunction() {}
 132   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getNetworks",
 133                              NETWORKINGPRIVATE_GETNETWORKS);
 134
 135  protected:
 136   ~NetworkingPrivateGetNetworksFunction() override;
 137
 138   // AsyncExtensionFunction overrides.
 139   bool RunAsync() override;
 140
 141  private:
 142   void Success(scoped_ptr<base::ListValue> network_list);
 143   void Failure(const std::string& error);
 144
 145   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetNetworksFunction);
 146 };
 147
 148 // Implements the chrome.networkingPrivate.getVisibleNetworks method.
 149 class NetworkingPrivateGetVisibleNetworksFunction
 150     : public AsyncExtensionFunction {
 151  public:
 152   NetworkingPrivateGetVisibleNetworksFunction() {}
 153   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getVisibleNetworks",
 154                              NETWORKINGPRIVATE_GETVISIBLENETWORKS);
 155
 156  protected:
 157   ~NetworkingPrivateGetVisibleNetworksFunction() override;
 158
 159   // AsyncExtensionFunction overrides.
 160   bool RunAsync() override;
 161
 162  private:
 163   void Success(scoped_ptr<base::ListValue> network_list);
 164   void Failure(const std::string& error);
 165
 166   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetVisibleNetworksFunction);
 167 };
 168
 169 // Implements the chrome.networkingPrivate.getEnabledNetworkTypes method.
 170 class NetworkingPrivateGetEnabledNetworkTypesFunction
 171     : public SyncExtensionFunction {
 172  public:
 173   NetworkingPrivateGetEnabledNetworkTypesFunction() {}
 174   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getEnabledNetworkTypes",
 175                              NETWORKINGPRIVATE_GETENABLEDNETWORKTYPES);
 176
 177  protected:
 178   ~NetworkingPrivateGetEnabledNetworkTypesFunction() override;
 179
 180   // SyncExtensionFunction overrides.
 181   bool RunSync() override;
 182
 183  private:
 184   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetEnabledNetworkTypesFunction);
 185 };
 186
 187 // Implements the chrome.networkingPrivate.enableNetworkType method.
 188 class NetworkingPrivateEnableNetworkTypeFunction
 189     : public SyncExtensionFunction {
 190  public:
 191   NetworkingPrivateEnableNetworkTypeFunction() {}
 192   DECLARE_EXTENSION_FUNCTION("networkingPrivate.enableNetworkType",
 193                              NETWORKINGPRIVATE_ENABLENETWORKTYPE);
 194
 195  protected:
 196   ~NetworkingPrivateEnableNetworkTypeFunction() override;
 197
 198   // SyncExtensionFunction overrides.
 199   bool RunSync() override;
 200
 201  private:
 202   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateEnableNetworkTypeFunction);
 203 };
 204
 205 // Implements the chrome.networkingPrivate.disableNetworkType method.
 206 class NetworkingPrivateDisableNetworkTypeFunction
 207     : public SyncExtensionFunction {
 208  public:
 209   NetworkingPrivateDisableNetworkTypeFunction() {}
 210   DECLARE_EXTENSION_FUNCTION("networkingPrivate.disableNetworkType",
 211                              NETWORKINGPRIVATE_DISABLENETWORKTYPE);
 212
 213  protected:
 214   ~NetworkingPrivateDisableNetworkTypeFunction() override;
 215
 216   // SyncExtensionFunction overrides.
 217   bool RunSync() override;
 218
 219  private:
 220   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateDisableNetworkTypeFunction);
 221 };
 222
 223 // Implements the chrome.networkingPrivate.requestNetworkScan method.
 224 class NetworkingPrivateRequestNetworkScanFunction
 225     : public SyncExtensionFunction {
 226  public:
 227   NetworkingPrivateRequestNetworkScanFunction() {}
 228   DECLARE_EXTENSION_FUNCTION("networkingPrivate.requestNetworkScan",
 229                              NETWORKINGPRIVATE_REQUESTNETWORKSCAN);
 230
 231  protected:
 232   ~NetworkingPrivateRequestNetworkScanFunction() override;
 233
 234   // SyncExtensionFunction overrides.
 235   bool RunSync() override;
 236
 237  private:
 238   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateRequestNetworkScanFunction);
 239 };
 240
 241 // Implements the chrome.networkingPrivate.startConnect method.
 242 class NetworkingPrivateStartConnectFunction : public AsyncExtensionFunction {
 243  public:
 244   NetworkingPrivateStartConnectFunction() {}
 245   DECLARE_EXTENSION_FUNCTION("networkingPrivate.startConnect",
 246                              NETWORKINGPRIVATE_STARTCONNECT);
 247
 248  protected:
 249   ~NetworkingPrivateStartConnectFunction() override;
 250
 251   // AsyncExtensionFunction overrides.
 252   bool RunAsync() override;
 253
 254  private:
 255   void Success();
 256   void Failure(const std::string& error);
 257
 258   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateStartConnectFunction);
 259 };
 260
 261 // Implements the chrome.networkingPrivate.startDisconnect method.
 262 class NetworkingPrivateStartDisconnectFunction : public AsyncExtensionFunction {
 263  public:
 264   NetworkingPrivateStartDisconnectFunction() {}
 265   DECLARE_EXTENSION_FUNCTION("networkingPrivate.startDisconnect",
 266                              NETWORKINGPRIVATE_STARTDISCONNECT);
 267
 268  protected:
 269   ~NetworkingPrivateStartDisconnectFunction() override;
 270
 271   // AsyncExtensionFunction overrides.
 272   bool RunAsync() override;
 273
 274  private:
 275   void Success();
 276   void Failure(const std::string& error);
 277
 278   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateStartDisconnectFunction);
 279 };
 280
 281 // Implements the chrome.networkingPrivate.verifyDestination method.
 282 class NetworkingPrivateVerifyDestinationFunction
 283     : public AsyncExtensionFunction {
 284  public:
 285   NetworkingPrivateVerifyDestinationFunction() {}
 286   DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyDestination",
 287                              NETWORKINGPRIVATE_VERIFYDESTINATION);
 288
 289  protected:
 290   ~NetworkingPrivateVerifyDestinationFunction() override;
 291
 292   // AsyncExtensionFunction overrides.
 293   bool RunAsync() override;
 294
 295   void Success(bool result);
 296   void Failure(const std::string& error);
 297
 298  private:
 299   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateVerifyDestinationFunction);
 300 };
 301
 302 // Implements the chrome.networkingPrivate.verifyAndEncryptCredentials method.
 303 class NetworkingPrivateVerifyAndEncryptCredentialsFunction
 304     : public AsyncExtensionFunction {
 305  public:
 306   NetworkingPrivateVerifyAndEncryptCredentialsFunction() {}
 307   DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyAndEncryptCredentials",
 308                              NETWORKINGPRIVATE_VERIFYANDENCRYPTCREDENTIALS);
 309
 310  protected:
 311   ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() override;
 312
 313   // AsyncExtensionFunction overrides.
 314   bool RunAsync() override;
 315
 316   void Success(const std::string& result);
 317   void Failure(const std::string& error);
 318
 319  private:
 320   DISALLOW_COPY_AND_ASSIGN(
 321       NetworkingPrivateVerifyAndEncryptCredentialsFunction);
 322 };
 323
 324 // Implements the chrome.networkingPrivate.verifyAndEncryptData method.
 325 class NetworkingPrivateVerifyAndEncryptDataFunction
 326     : public AsyncExtensionFunction {
 327  public:
 328   NetworkingPrivateVerifyAndEncryptDataFunction() {}
 329   DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyAndEncryptData",
 330                              NETWORKINGPRIVATE_VERIFYANDENCRYPTDATA);
 331
 332  protected:
 333   ~NetworkingPrivateVerifyAndEncryptDataFunction() override;
 334
 335   // AsyncExtensionFunction overrides.
 336   bool RunAsync() override;
 337
 338   void Success(const std::string& result);
 339   void Failure(const std::string& error);
 340
 341  private:
 342   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateVerifyAndEncryptDataFunction);
 343 };
 344
 345 // Implements the chrome.networkingPrivate.setWifiTDLSEnabledState method.
 346 class NetworkingPrivateSetWifiTDLSEnabledStateFunction
 347     : public AsyncExtensionFunction {
 348  public:
 349   NetworkingPrivateSetWifiTDLSEnabledStateFunction() {}
 350   DECLARE_EXTENSION_FUNCTION("networkingPrivate.setWifiTDLSEnabledState",
 351                              NETWORKINGPRIVATE_SETWIFITDLSENABLEDSTATE);
 352
 353  protected:
 354   ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() override;
 355
 356   // AsyncExtensionFunction overrides.
 357   bool RunAsync() override;
 358
 359   void Success(const std::string& result);
 360   void Failure(const std::string& error);
 361
 362  private:
 363   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateSetWifiTDLSEnabledStateFunction);
 364 };
 365
 366 // Implements the chrome.networkingPrivate.getWifiTDLSStatus method.
 367 class NetworkingPrivateGetWifiTDLSStatusFunction
 368     : public AsyncExtensionFunction {
 369  public:
 370   NetworkingPrivateGetWifiTDLSStatusFunction() {}
 371   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getWifiTDLSStatus",
 372                              NETWORKINGPRIVATE_GETWIFITDLSSTATUS);
 373
 374  protected:
 375   ~NetworkingPrivateGetWifiTDLSStatusFunction() override;
 376
 377   // AsyncExtensionFunction overrides.
 378   bool RunAsync() override;
 379
 380   void Success(const std::string& result);
 381   void Failure(const std::string& error);
 382
 383  private:
 384   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetWifiTDLSStatusFunction);
 385 };
 386
 387 class NetworkingPrivateGetCaptivePortalStatusFunction
 388     : public AsyncExtensionFunction {
 389  public:
 390   NetworkingPrivateGetCaptivePortalStatusFunction() {}
 391   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getCaptivePortalStatus",
 392                              NETWORKINGPRIVATE_GETCAPTIVEPORTALSTATUS);
 393
 394   // AsyncExtensionFunction overrides.
 395   bool RunAsync() override;
 396
 397  protected:
 398   ~NetworkingPrivateGetCaptivePortalStatusFunction() override;
 399
 400  private:
 401   void Success(const std::string& result);
 402   void Failure(const std::string& error);
 403
 404   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetCaptivePortalStatusFunction);
 405 };
 406
 407 }  // namespace extensions
 408
 409 #endif  // EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_API_H_