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 kErrorInvalidNetworkOperation[];
  21 extern const char kErrorNetworkUnavailable[];
  22 extern const char kErrorEncryptionError[];
  23 extern const char kErrorNotReady[];
  24 extern const char kErrorNotSupported[];
  25 extern const char kErrorSimLocked[];
  26
  27 }  // namespace networking_private
  28
  29 // Implements the chrome.networkingPrivate.getProperties method.
  30 class NetworkingPrivateGetPropertiesFunction : public AsyncExtensionFunction {
  31  public:
  32   NetworkingPrivateGetPropertiesFunction() {}
  33   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getProperties",
  34                              NETWORKINGPRIVATE_GETPROPERTIES);
  35
  36  protected:
  37   ~NetworkingPrivateGetPropertiesFunction() override;
  38
  39   // AsyncExtensionFunction overrides.
  40   bool RunAsync() override;
  41
  42  private:
  43   void Success(scoped_ptr<base::DictionaryValue> result);
  44   void Failure(const std::string& error_name);
  45
  46   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetPropertiesFunction);
  47 };
  48
  49 // Implements the chrome.networkingPrivate.getManagedProperties method.
  50 class NetworkingPrivateGetManagedPropertiesFunction
  51     : public AsyncExtensionFunction {
  52  public:
  53   NetworkingPrivateGetManagedPropertiesFunction() {}
  54   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getManagedProperties",
  55                              NETWORKINGPRIVATE_GETMANAGEDPROPERTIES);
  56
  57  protected:
  58   ~NetworkingPrivateGetManagedPropertiesFunction() override;
  59
  60   // AsyncExtensionFunction overrides.
  61   bool RunAsync() override;
  62
  63  private:
  64   void Success(scoped_ptr<base::DictionaryValue> result);
  65   void Failure(const std::string& error);
  66
  67   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetManagedPropertiesFunction);
  68 };
  69
  70 // Implements the chrome.networkingPrivate.getState method.
  71 class NetworkingPrivateGetStateFunction : public AsyncExtensionFunction {
  72  public:
  73   NetworkingPrivateGetStateFunction() {}
  74   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getState",
  75                              NETWORKINGPRIVATE_GETSTATE);
  76
  77  protected:
  78   ~NetworkingPrivateGetStateFunction() override;
  79
  80   // AsyncExtensionFunction overrides.
  81   bool RunAsync() override;
  82
  83  private:
  84   void Success(scoped_ptr<base::DictionaryValue> result);
  85   void Failure(const std::string& error);
  86
  87   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetStateFunction);
  88 };
  89
  90 // Implements the chrome.networkingPrivate.setProperties method.
  91 class NetworkingPrivateSetPropertiesFunction : public AsyncExtensionFunction {
  92  public:
  93   NetworkingPrivateSetPropertiesFunction() {}
  94   DECLARE_EXTENSION_FUNCTION("networkingPrivate.setProperties",
  95                              NETWORKINGPRIVATE_SETPROPERTIES);
  96
  97  protected:
  98   ~NetworkingPrivateSetPropertiesFunction() override;
  99
 100   // AsyncExtensionFunction overrides.
 101   bool RunAsync() override;
 102
 103  private:
 104   void Success();
 105   void Failure(const std::string& error);
 106
 107   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateSetPropertiesFunction);
 108 };
 109
 110 // Implements the chrome.networkingPrivate.createNetwork method.
 111 class NetworkingPrivateCreateNetworkFunction : public AsyncExtensionFunction {
 112  public:
 113   NetworkingPrivateCreateNetworkFunction() {}
 114   DECLARE_EXTENSION_FUNCTION("networkingPrivate.createNetwork",
 115                              NETWORKINGPRIVATE_CREATENETWORK);
 116
 117  protected:
 118   ~NetworkingPrivateCreateNetworkFunction() override;
 119
 120   // AsyncExtensionFunction overrides.
 121   bool RunAsync() override;
 122
 123  private:
 124   void Success(const std::string& guid);
 125   void Failure(const std::string& error);
 126
 127   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCreateNetworkFunction);
 128 };
 129
 130 // Implements the chrome.networkingPrivate.createNetwork method.
 131 class NetworkingPrivateForgetNetworkFunction : public AsyncExtensionFunction {
 132  public:
 133   NetworkingPrivateForgetNetworkFunction() {}
 134   DECLARE_EXTENSION_FUNCTION("networkingPrivate.forgetNetwork",
 135                              NETWORKINGPRIVATE_FORGETNETWORK);
 136
 137  protected:
 138   ~NetworkingPrivateForgetNetworkFunction() override;
 139
 140   // AsyncExtensionFunction overrides.
 141   bool RunAsync() override;
 142
 143  private:
 144   void Success();
 145   void Failure(const std::string& error);
 146
 147   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateForgetNetworkFunction);
 148 };
 149
 150 // Implements the chrome.networkingPrivate.getNetworks method.
 151 class NetworkingPrivateGetNetworksFunction : public AsyncExtensionFunction {
 152  public:
 153   NetworkingPrivateGetNetworksFunction() {}
 154   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getNetworks",
 155                              NETWORKINGPRIVATE_GETNETWORKS);
 156
 157  protected:
 158   ~NetworkingPrivateGetNetworksFunction() override;
 159
 160   // AsyncExtensionFunction overrides.
 161   bool RunAsync() override;
 162
 163  private:
 164   void Success(scoped_ptr<base::ListValue> network_list);
 165   void Failure(const std::string& error);
 166
 167   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetNetworksFunction);
 168 };
 169
 170 // Implements the chrome.networkingPrivate.getVisibleNetworks method.
 171 class NetworkingPrivateGetVisibleNetworksFunction
 172     : public AsyncExtensionFunction {
 173  public:
 174   NetworkingPrivateGetVisibleNetworksFunction() {}
 175   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getVisibleNetworks",
 176                              NETWORKINGPRIVATE_GETVISIBLENETWORKS);
 177
 178  protected:
 179   ~NetworkingPrivateGetVisibleNetworksFunction() override;
 180
 181   // AsyncExtensionFunction overrides.
 182   bool RunAsync() override;
 183
 184  private:
 185   void Success(scoped_ptr<base::ListValue> network_list);
 186   void Failure(const std::string& error);
 187
 188   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetVisibleNetworksFunction);
 189 };
 190
 191 // Implements the chrome.networkingPrivate.getEnabledNetworkTypes method.
 192 class NetworkingPrivateGetEnabledNetworkTypesFunction
 193     : public SyncExtensionFunction {
 194  public:
 195   NetworkingPrivateGetEnabledNetworkTypesFunction() {}
 196   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getEnabledNetworkTypes",
 197                              NETWORKINGPRIVATE_GETENABLEDNETWORKTYPES);
 198
 199  protected:
 200   ~NetworkingPrivateGetEnabledNetworkTypesFunction() override;
 201
 202   // SyncExtensionFunction overrides.
 203   bool RunSync() override;
 204
 205  private:
 206   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetEnabledNetworkTypesFunction);
 207 };
 208
 209 // Implements the chrome.networkingPrivate.getDeviceStates method.
 210 class NetworkingPrivateGetDeviceStatesFunction : public SyncExtensionFunction {
 211  public:
 212   NetworkingPrivateGetDeviceStatesFunction() {}
 213   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getDeviceStates",
 214                              NETWORKINGPRIVATE_GETDEVICESTATES);
 215
 216  protected:
 217   ~NetworkingPrivateGetDeviceStatesFunction() override;
 218
 219   // SyncExtensionFunction overrides.
 220   bool RunSync() override;
 221
 222  private:
 223   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetDeviceStatesFunction);
 224 };
 225
 226 // Implements the chrome.networkingPrivate.enableNetworkType method.
 227 class NetworkingPrivateEnableNetworkTypeFunction
 228     : public SyncExtensionFunction {
 229  public:
 230   NetworkingPrivateEnableNetworkTypeFunction() {}
 231   DECLARE_EXTENSION_FUNCTION("networkingPrivate.enableNetworkType",
 232                              NETWORKINGPRIVATE_ENABLENETWORKTYPE);
 233
 234  protected:
 235   ~NetworkingPrivateEnableNetworkTypeFunction() override;
 236
 237   // SyncExtensionFunction overrides.
 238   bool RunSync() override;
 239
 240  private:
 241   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateEnableNetworkTypeFunction);
 242 };
 243
 244 // Implements the chrome.networkingPrivate.disableNetworkType method.
 245 class NetworkingPrivateDisableNetworkTypeFunction
 246     : public SyncExtensionFunction {
 247  public:
 248   NetworkingPrivateDisableNetworkTypeFunction() {}
 249   DECLARE_EXTENSION_FUNCTION("networkingPrivate.disableNetworkType",
 250                              NETWORKINGPRIVATE_DISABLENETWORKTYPE);
 251
 252  protected:
 253   ~NetworkingPrivateDisableNetworkTypeFunction() override;
 254
 255   // SyncExtensionFunction overrides.
 256   bool RunSync() override;
 257
 258  private:
 259   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateDisableNetworkTypeFunction);
 260 };
 261
 262 // Implements the chrome.networkingPrivate.requestNetworkScan method.
 263 class NetworkingPrivateRequestNetworkScanFunction
 264     : public SyncExtensionFunction {
 265  public:
 266   NetworkingPrivateRequestNetworkScanFunction() {}
 267   DECLARE_EXTENSION_FUNCTION("networkingPrivate.requestNetworkScan",
 268                              NETWORKINGPRIVATE_REQUESTNETWORKSCAN);
 269
 270  protected:
 271   ~NetworkingPrivateRequestNetworkScanFunction() override;
 272
 273   // SyncExtensionFunction overrides.
 274   bool RunSync() override;
 275
 276  private:
 277   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateRequestNetworkScanFunction);
 278 };
 279
 280 // Implements the chrome.networkingPrivate.startConnect method.
 281 class NetworkingPrivateStartConnectFunction : public AsyncExtensionFunction {
 282  public:
 283   NetworkingPrivateStartConnectFunction() {}
 284   DECLARE_EXTENSION_FUNCTION("networkingPrivate.startConnect",
 285                              NETWORKINGPRIVATE_STARTCONNECT);
 286
 287  protected:
 288   ~NetworkingPrivateStartConnectFunction() override;
 289
 290   // AsyncExtensionFunction overrides.
 291   bool RunAsync() override;
 292
 293  private:
 294   void Success();
 295   void Failure(const std::string& error);
 296
 297   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateStartConnectFunction);
 298 };
 299
 300 // Implements the chrome.networkingPrivate.startDisconnect method.
 301 class NetworkingPrivateStartDisconnectFunction : public AsyncExtensionFunction {
 302  public:
 303   NetworkingPrivateStartDisconnectFunction() {}
 304   DECLARE_EXTENSION_FUNCTION("networkingPrivate.startDisconnect",
 305                              NETWORKINGPRIVATE_STARTDISCONNECT);
 306
 307  protected:
 308   ~NetworkingPrivateStartDisconnectFunction() override;
 309
 310   // AsyncExtensionFunction overrides.
 311   bool RunAsync() override;
 312
 313  private:
 314   void Success();
 315   void Failure(const std::string& error);
 316
 317   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateStartDisconnectFunction);
 318 };
 319
 320 // Implements the chrome.networkingPrivate.startActivate method.
 321 class NetworkingPrivateStartActivateFunction : public AsyncExtensionFunction {
 322  public:
 323   NetworkingPrivateStartActivateFunction() {}
 324   DECLARE_EXTENSION_FUNCTION("networkingPrivate.startActivate",
 325                              NETWORKINGPRIVATE_STARTACTIVATE);
 326
 327  protected:
 328   ~NetworkingPrivateStartActivateFunction() override;
 329
 330   // AsyncExtensionFunction overrides.
 331   bool RunAsync() override;
 332
 333  private:
 334   void Success();
 335   void Failure(const std::string& error);
 336
 337   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateStartActivateFunction);
 338 };
 339
 340 // Implements the chrome.networkingPrivate.verifyDestination method.
 341 class NetworkingPrivateVerifyDestinationFunction
 342     : public AsyncExtensionFunction {
 343  public:
 344   NetworkingPrivateVerifyDestinationFunction() {}
 345   DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyDestination",
 346                              NETWORKINGPRIVATE_VERIFYDESTINATION);
 347
 348  protected:
 349   ~NetworkingPrivateVerifyDestinationFunction() override;
 350
 351   // AsyncExtensionFunction overrides.
 352   bool RunAsync() override;
 353
 354   void Success(bool result);
 355   void Failure(const std::string& error);
 356
 357  private:
 358   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateVerifyDestinationFunction);
 359 };
 360
 361 // Implements the chrome.networkingPrivate.verifyAndEncryptCredentials method.
 362 class NetworkingPrivateVerifyAndEncryptCredentialsFunction
 363     : public AsyncExtensionFunction {
 364  public:
 365   NetworkingPrivateVerifyAndEncryptCredentialsFunction() {}
 366   DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyAndEncryptCredentials",
 367                              NETWORKINGPRIVATE_VERIFYANDENCRYPTCREDENTIALS);
 368
 369  protected:
 370   ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() override;
 371
 372   // AsyncExtensionFunction overrides.
 373   bool RunAsync() override;
 374
 375   void Success(const std::string& result);
 376   void Failure(const std::string& error);
 377
 378  private:
 379   DISALLOW_COPY_AND_ASSIGN(
 380       NetworkingPrivateVerifyAndEncryptCredentialsFunction);
 381 };
 382
 383 // Implements the chrome.networkingPrivate.verifyAndEncryptData method.
 384 class NetworkingPrivateVerifyAndEncryptDataFunction
 385     : public AsyncExtensionFunction {
 386  public:
 387   NetworkingPrivateVerifyAndEncryptDataFunction() {}
 388   DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyAndEncryptData",
 389                              NETWORKINGPRIVATE_VERIFYANDENCRYPTDATA);
 390
 391  protected:
 392   ~NetworkingPrivateVerifyAndEncryptDataFunction() override;
 393
 394   // AsyncExtensionFunction overrides.
 395   bool RunAsync() override;
 396
 397   void Success(const std::string& result);
 398   void Failure(const std::string& error);
 399
 400  private:
 401   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateVerifyAndEncryptDataFunction);
 402 };
 403
 404 // Implements the chrome.networkingPrivate.setWifiTDLSEnabledState method.
 405 class NetworkingPrivateSetWifiTDLSEnabledStateFunction
 406     : public AsyncExtensionFunction {
 407  public:
 408   NetworkingPrivateSetWifiTDLSEnabledStateFunction() {}
 409   DECLARE_EXTENSION_FUNCTION("networkingPrivate.setWifiTDLSEnabledState",
 410                              NETWORKINGPRIVATE_SETWIFITDLSENABLEDSTATE);
 411
 412  protected:
 413   ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() override;
 414
 415   // AsyncExtensionFunction overrides.
 416   bool RunAsync() override;
 417
 418   void Success(const std::string& result);
 419   void Failure(const std::string& error);
 420
 421  private:
 422   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateSetWifiTDLSEnabledStateFunction);
 423 };
 424
 425 // Implements the chrome.networkingPrivate.getWifiTDLSStatus method.
 426 class NetworkingPrivateGetWifiTDLSStatusFunction
 427     : public AsyncExtensionFunction {
 428  public:
 429   NetworkingPrivateGetWifiTDLSStatusFunction() {}
 430   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getWifiTDLSStatus",
 431                              NETWORKINGPRIVATE_GETWIFITDLSSTATUS);
 432
 433  protected:
 434   ~NetworkingPrivateGetWifiTDLSStatusFunction() override;
 435
 436   // AsyncExtensionFunction overrides.
 437   bool RunAsync() override;
 438
 439   void Success(const std::string& result);
 440   void Failure(const std::string& error);
 441
 442  private:
 443   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetWifiTDLSStatusFunction);
 444 };
 445
 446 class NetworkingPrivateGetCaptivePortalStatusFunction
 447     : public AsyncExtensionFunction {
 448  public:
 449   NetworkingPrivateGetCaptivePortalStatusFunction() {}
 450   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getCaptivePortalStatus",
 451                              NETWORKINGPRIVATE_GETCAPTIVEPORTALSTATUS);
 452
 453   // AsyncExtensionFunction overrides.
 454   bool RunAsync() override;
 455
 456  protected:
 457   ~NetworkingPrivateGetCaptivePortalStatusFunction() override;
 458
 459  private:
 460   void Success(const std::string& result);
 461   void Failure(const std::string& error);
 462
 463   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetCaptivePortalStatusFunction);
 464 };
 465
 466 class NetworkingPrivateUnlockCellularSimFunction
 467     : public AsyncExtensionFunction {
 468  public:
 469   NetworkingPrivateUnlockCellularSimFunction() {}
 470   DECLARE_EXTENSION_FUNCTION("networkingPrivate.unlockCellularSim",
 471                              NETWORKINGPRIVATE_UNLOCKCELLULARSIM);
 472
 473   // AsyncExtensionFunction overrides.
 474   bool RunAsync() override;
 475
 476  protected:
 477   ~NetworkingPrivateUnlockCellularSimFunction() override;
 478
 479  private:
 480   void Success();
 481   void Failure(const std::string& error);
 482
 483   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateUnlockCellularSimFunction);
 484 };
 485
 486 class NetworkingPrivateSetCellularSimStateFunction
 487     : public AsyncExtensionFunction {
 488  public:
 489   NetworkingPrivateSetCellularSimStateFunction() {}
 490   DECLARE_EXTENSION_FUNCTION("networkingPrivate.setCellularSimState",
 491                              NETWORKINGPRIVATE_SETCELLULARSIMSTATE);
 492
 493   // AsyncExtensionFunction overrides.
 494   bool RunAsync() override;
 495
 496  protected:
 497   ~NetworkingPrivateSetCellularSimStateFunction() override;
 498
 499  private:
 500   void Success();
 501   void Failure(const std::string& error);
 502
 503   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateSetCellularSimStateFunction);
 504 };
 505
 506 }  // namespace extensions
 507
 508 #endif  // EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_API_H_