Home | History | Annotate | Download | only in networking_private 
      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 #include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/bind_helpers.h"
      9 #include "base/callback.h"
     10 #include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
     11 #include "chrome/common/extensions/api/networking_private.h"
     12 #include "components/onc/onc_constants.h"
     13 #include "extensions/browser/extension_function_registry.h"
     14 
     15 namespace {
     16 
     17 const int kDefaultNetworkListLimit = 1000;
     18 
     19 extensions::NetworkingPrivateDelegate* GetDelegate(
     20     content::BrowserContext* browser_context) {
     21   return extensions::NetworkingPrivateDelegate::GetForBrowserContext(
     22       browser_context);
     23 }
     24 
     25 }  // namespace
     26 
     27 namespace private_api = extensions::api::networking_private;
     28 
     29 namespace extensions {
     30 
     31 namespace networking_private {
     32 
     33 // static
     34 const char kErrorInvalidNetworkGuid[] = "Error.InvalidNetworkGuid";
     35 const char kErrorNetworkUnavailable[] = "Error.NetworkUnavailable";
     36 const char kErrorEncryptionError[] = "Error.EncryptionError";
     37 const char kErrorNotReady[] = "Error.NotReady";
     38 const char kErrorNotSupported[] = "Error.NotSupported";
     39 
     40 }  // namespace networking_private
     41 
     42 ////////////////////////////////////////////////////////////////////////////////
     43 // NetworkingPrivateGetPropertiesFunction
     44 
     45 NetworkingPrivateGetPropertiesFunction::
     46     ~NetworkingPrivateGetPropertiesFunction() {
     47 }
     48 
     49 bool NetworkingPrivateGetPropertiesFunction::RunAsync() {
     50   scoped_ptr<private_api::GetProperties::Params> params =
     51       private_api::GetProperties::Params::Create(*args_);
     52   EXTENSION_FUNCTION_VALIDATE(params);
     53 
     54   GetDelegate(browser_context())->GetProperties(
     55       params->network_guid,
     56       base::Bind(&NetworkingPrivateGetPropertiesFunction::Success, this),
     57       base::Bind(&NetworkingPrivateGetPropertiesFunction::Failure, this));
     58   return true;
     59 }
     60 
     61 void NetworkingPrivateGetPropertiesFunction::Success(
     62     scoped_ptr<base::DictionaryValue> result) {
     63   SetResult(result.release());
     64   SendResponse(true);
     65 }
     66 
     67 void NetworkingPrivateGetPropertiesFunction::Failure(const std::string& error) {
     68   error_ = error;
     69   SendResponse(false);
     70 }
     71 
     72 ////////////////////////////////////////////////////////////////////////////////
     73 // NetworkingPrivateGetManagedPropertiesFunction
     74 
     75 NetworkingPrivateGetManagedPropertiesFunction::
     76     ~NetworkingPrivateGetManagedPropertiesFunction() {
     77 }
     78 
     79 bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() {
     80   scoped_ptr<private_api::GetManagedProperties::Params> params =
     81       private_api::GetManagedProperties::Params::Create(*args_);
     82   EXTENSION_FUNCTION_VALIDATE(params);
     83 
     84   GetDelegate(browser_context())->GetManagedProperties(
     85       params->network_guid,
     86       base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success, this),
     87       base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
     88                  this));
     89   return true;
     90 }
     91 
     92 void NetworkingPrivateGetManagedPropertiesFunction::Success(
     93     scoped_ptr<base::DictionaryValue> result) {
     94   SetResult(result.release());
     95   SendResponse(true);
     96 }
     97 
     98 void NetworkingPrivateGetManagedPropertiesFunction::Failure(
     99     const std::string& error) {
    100   error_ = error;
    101   SendResponse(false);
    102 }
    103 
    104 ////////////////////////////////////////////////////////////////////////////////
    105 // NetworkingPrivateGetStateFunction
    106 
    107 NetworkingPrivateGetStateFunction::~NetworkingPrivateGetStateFunction() {
    108 }
    109 
    110 bool NetworkingPrivateGetStateFunction::RunAsync() {
    111   scoped_ptr<private_api::GetState::Params> params =
    112       private_api::GetState::Params::Create(*args_);
    113   EXTENSION_FUNCTION_VALIDATE(params);
    114 
    115   GetDelegate(browser_context())->GetState(
    116       params->network_guid,
    117       base::Bind(&NetworkingPrivateGetStateFunction::Success, this),
    118       base::Bind(&NetworkingPrivateGetStateFunction::Failure, this));
    119   return true;
    120 }
    121 
    122 void NetworkingPrivateGetStateFunction::Success(
    123     scoped_ptr<base::DictionaryValue> result) {
    124   SetResult(result.release());
    125   SendResponse(true);
    126 }
    127 
    128 void NetworkingPrivateGetStateFunction::Failure(const std::string& error) {
    129   error_ = error;
    130   SendResponse(false);
    131 }
    132 
    133 ////////////////////////////////////////////////////////////////////////////////
    134 // NetworkingPrivateSetPropertiesFunction
    135 
    136 NetworkingPrivateSetPropertiesFunction::
    137     ~NetworkingPrivateSetPropertiesFunction() {
    138 }
    139 
    140 bool NetworkingPrivateSetPropertiesFunction::RunAsync() {
    141   scoped_ptr<private_api::SetProperties::Params> params =
    142       private_api::SetProperties::Params::Create(*args_);
    143   EXTENSION_FUNCTION_VALIDATE(params);
    144 
    145   scoped_ptr<base::DictionaryValue> properties_dict(
    146       params->properties.ToValue());
    147 
    148   GetDelegate(browser_context())->SetProperties(
    149       params->network_guid,
    150       properties_dict.Pass(),
    151       base::Bind(&NetworkingPrivateSetPropertiesFunction::Success, this),
    152       base::Bind(&NetworkingPrivateSetPropertiesFunction::Failure, this));
    153   return true;
    154 }
    155 
    156 void NetworkingPrivateSetPropertiesFunction::Success() {
    157   SendResponse(true);
    158 }
    159 
    160 void NetworkingPrivateSetPropertiesFunction::Failure(const std::string& error) {
    161   error_ = error;
    162   SendResponse(false);
    163 }
    164 
    165 ////////////////////////////////////////////////////////////////////////////////
    166 // NetworkingPrivateCreateNetworkFunction
    167 
    168 NetworkingPrivateCreateNetworkFunction::
    169     ~NetworkingPrivateCreateNetworkFunction() {
    170 }
    171 
    172 bool NetworkingPrivateCreateNetworkFunction::RunAsync() {
    173   scoped_ptr<private_api::CreateNetwork::Params> params =
    174       private_api::CreateNetwork::Params::Create(*args_);
    175   EXTENSION_FUNCTION_VALIDATE(params);
    176 
    177   scoped_ptr<base::DictionaryValue> properties_dict(
    178       params->properties.ToValue());
    179 
    180   GetDelegate(browser_context())->CreateNetwork(
    181       params->shared,
    182       properties_dict.Pass(),
    183       base::Bind(&NetworkingPrivateCreateNetworkFunction::Success, this),
    184       base::Bind(&NetworkingPrivateCreateNetworkFunction::Failure, this));
    185   return true;
    186 }
    187 
    188 void NetworkingPrivateCreateNetworkFunction::Success(const std::string& guid) {
    189   results_ = private_api::CreateNetwork::Results::Create(guid);
    190   SendResponse(true);
    191 }
    192 
    193 void NetworkingPrivateCreateNetworkFunction::Failure(const std::string& error) {
    194   error_ = error;
    195   SendResponse(false);
    196 }
    197 
    198 ////////////////////////////////////////////////////////////////////////////////
    199 // NetworkingPrivateGetNetworksFunction
    200 
    201 NetworkingPrivateGetNetworksFunction::~NetworkingPrivateGetNetworksFunction() {
    202 }
    203 
    204 bool NetworkingPrivateGetNetworksFunction::RunAsync() {
    205   scoped_ptr<private_api::GetNetworks::Params> params =
    206       private_api::GetNetworks::Params::Create(*args_);
    207   EXTENSION_FUNCTION_VALIDATE(params);
    208 
    209   std::string network_type = private_api::ToString(params->filter.network_type);
    210   const bool configured_only =
    211       params->filter.configured ? *params->filter.configured : false;
    212   const bool visible_only =
    213       params->filter.visible ? *params->filter.visible : false;
    214   const int limit =
    215       params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit;
    216 
    217   GetDelegate(browser_context())->GetNetworks(
    218       network_type,
    219       configured_only,
    220       visible_only,
    221       limit,
    222       base::Bind(&NetworkingPrivateGetNetworksFunction::Success, this),
    223       base::Bind(&NetworkingPrivateGetNetworksFunction::Failure, this));
    224   return true;
    225 }
    226 
    227 void NetworkingPrivateGetNetworksFunction::Success(
    228     scoped_ptr<base::ListValue> network_list) {
    229   SetResult(network_list.release());
    230   SendResponse(true);
    231 }
    232 
    233 void NetworkingPrivateGetNetworksFunction::Failure(const std::string& error) {
    234   error_ = error;
    235   SendResponse(false);
    236 }
    237 
    238 ////////////////////////////////////////////////////////////////////////////////
    239 // NetworkingPrivateGetVisibleNetworksFunction
    240 
    241 NetworkingPrivateGetVisibleNetworksFunction::
    242     ~NetworkingPrivateGetVisibleNetworksFunction() {
    243 }
    244 
    245 bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() {
    246   scoped_ptr<private_api::GetVisibleNetworks::Params> params =
    247       private_api::GetVisibleNetworks::Params::Create(*args_);
    248   EXTENSION_FUNCTION_VALIDATE(params);
    249 
    250   std::string network_type = private_api::ToString(params->network_type);
    251   const bool configured_only = false;
    252   const bool visible_only = true;
    253 
    254   GetDelegate(browser_context())->GetNetworks(
    255       network_type,
    256       configured_only,
    257       visible_only,
    258       kDefaultNetworkListLimit,
    259       base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Success, this),
    260       base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Failure, this));
    261   return true;
    262 }
    263 
    264 void NetworkingPrivateGetVisibleNetworksFunction::Success(
    265     scoped_ptr<base::ListValue> network_properties_list) {
    266   SetResult(network_properties_list.release());
    267   SendResponse(true);
    268 }
    269 
    270 void NetworkingPrivateGetVisibleNetworksFunction::Failure(
    271     const std::string& error) {
    272   error_ = error;
    273   SendResponse(false);
    274 }
    275 
    276 ////////////////////////////////////////////////////////////////////////////////
    277 // NetworkingPrivateGetEnabledNetworkTypesFunction
    278 
    279 NetworkingPrivateGetEnabledNetworkTypesFunction::
    280     ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
    281 }
    282 
    283 bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
    284   scoped_ptr<base::ListValue> enabled_networks_onc_types(
    285       GetDelegate(browser_context())->GetEnabledNetworkTypes());
    286   if (!enabled_networks_onc_types) {
    287     error_ = networking_private::kErrorNotSupported;
    288     return false;
    289   }
    290   scoped_ptr<base::ListValue> enabled_networks_list(new base::ListValue);
    291   for (base::ListValue::iterator iter = enabled_networks_onc_types->begin();
    292        iter != enabled_networks_onc_types->end(); ++iter) {
    293     std::string type;
    294     if (!(*iter)->GetAsString(&type))
    295       NOTREACHED();
    296     if (type == ::onc::network_type::kEthernet) {
    297       enabled_networks_list->AppendString(api::networking_private::ToString(
    298           api::networking_private::NETWORK_TYPE_ETHERNET));
    299     } else if (type == ::onc::network_type::kWiFi) {
    300       enabled_networks_list->AppendString(api::networking_private::ToString(
    301           api::networking_private::NETWORK_TYPE_WIFI));
    302     } else if (type == ::onc::network_type::kWimax) {
    303       enabled_networks_list->AppendString(api::networking_private::ToString(
    304           api::networking_private::NETWORK_TYPE_WIMAX));
    305     } else if (type == ::onc::network_type::kCellular) {
    306       enabled_networks_list->AppendString(api::networking_private::ToString(
    307           api::networking_private::NETWORK_TYPE_CELLULAR));
    308     } else {
    309       LOG(ERROR) << "networkingPrivate: Unexpected type: " << type;
    310     }
    311   }
    312   SetResult(enabled_networks_list.release());
    313   return true;
    314 }
    315 
    316 ////////////////////////////////////////////////////////////////////////////////
    317 // NetworkingPrivateEnableNetworkTypeFunction
    318 
    319 NetworkingPrivateEnableNetworkTypeFunction::
    320     ~NetworkingPrivateEnableNetworkTypeFunction() {
    321 }
    322 
    323 bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
    324   scoped_ptr<private_api::EnableNetworkType::Params> params =
    325       private_api::EnableNetworkType::Params::Create(*args_);
    326   EXTENSION_FUNCTION_VALIDATE(params);
    327 
    328   return GetDelegate(browser_context())->EnableNetworkType(
    329       private_api::ToString(params->network_type));
    330 }
    331 
    332 ////////////////////////////////////////////////////////////////////////////////
    333 // NetworkingPrivateDisableNetworkTypeFunction
    334 
    335 NetworkingPrivateDisableNetworkTypeFunction::
    336     ~NetworkingPrivateDisableNetworkTypeFunction() {
    337 }
    338 
    339 bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
    340   scoped_ptr<private_api::DisableNetworkType::Params> params =
    341       private_api::DisableNetworkType::Params::Create(*args_);
    342 
    343   return GetDelegate(browser_context())->DisableNetworkType(
    344       private_api::ToString(params->network_type));
    345 }
    346 
    347 ////////////////////////////////////////////////////////////////////////////////
    348 // NetworkingPrivateRequestNetworkScanFunction
    349 
    350 NetworkingPrivateRequestNetworkScanFunction::
    351     ~NetworkingPrivateRequestNetworkScanFunction() {
    352 }
    353 
    354 bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
    355   return GetDelegate(browser_context())->RequestScan();
    356 }
    357 
    358 ////////////////////////////////////////////////////////////////////////////////
    359 // NetworkingPrivateStartConnectFunction
    360 
    361 NetworkingPrivateStartConnectFunction::
    362     ~NetworkingPrivateStartConnectFunction() {
    363 }
    364 
    365 bool NetworkingPrivateStartConnectFunction::RunAsync() {
    366   scoped_ptr<private_api::StartConnect::Params> params =
    367       private_api::StartConnect::Params::Create(*args_);
    368   EXTENSION_FUNCTION_VALIDATE(params);
    369 
    370   GetDelegate(browser_context())->StartConnect(
    371       params->network_guid,
    372       base::Bind(&NetworkingPrivateStartConnectFunction::Success, this),
    373       base::Bind(&NetworkingPrivateStartConnectFunction::Failure, this));
    374   return true;
    375 }
    376 
    377 void NetworkingPrivateStartConnectFunction::Success() {
    378   SendResponse(true);
    379 }
    380 
    381 void NetworkingPrivateStartConnectFunction::Failure(const std::string& error) {
    382   error_ = error;
    383   SendResponse(false);
    384 }
    385 
    386 ////////////////////////////////////////////////////////////////////////////////
    387 // NetworkingPrivateStartDisconnectFunction
    388 
    389 NetworkingPrivateStartDisconnectFunction::
    390     ~NetworkingPrivateStartDisconnectFunction() {
    391 }
    392 
    393 bool NetworkingPrivateStartDisconnectFunction::RunAsync() {
    394   scoped_ptr<private_api::StartDisconnect::Params> params =
    395       private_api::StartDisconnect::Params::Create(*args_);
    396   EXTENSION_FUNCTION_VALIDATE(params);
    397 
    398   GetDelegate(browser_context())->StartDisconnect(
    399       params->network_guid,
    400       base::Bind(&NetworkingPrivateStartDisconnectFunction::Success, this),
    401       base::Bind(&NetworkingPrivateStartDisconnectFunction::Failure, this));
    402   return true;
    403 }
    404 
    405 void NetworkingPrivateStartDisconnectFunction::Success() {
    406   SendResponse(true);
    407 }
    408 
    409 void NetworkingPrivateStartDisconnectFunction::Failure(
    410     const std::string& error) {
    411   error_ = error;
    412   SendResponse(false);
    413 }
    414 
    415 ////////////////////////////////////////////////////////////////////////////////
    416 // NetworkingPrivateVerifyDestinationFunction
    417 
    418 NetworkingPrivateVerifyDestinationFunction::
    419     ~NetworkingPrivateVerifyDestinationFunction() {
    420 }
    421 
    422 bool NetworkingPrivateVerifyDestinationFunction::RunAsync() {
    423   scoped_ptr<private_api::VerifyDestination::Params> params =
    424       private_api::VerifyDestination::Params::Create(*args_);
    425   EXTENSION_FUNCTION_VALIDATE(params);
    426 
    427   GetDelegate(browser_context())->VerifyDestination(
    428       params->properties,
    429       base::Bind(&NetworkingPrivateVerifyDestinationFunction::Success, this),
    430       base::Bind(&NetworkingPrivateVerifyDestinationFunction::Failure, this));
    431   return true;
    432 }
    433 
    434 void NetworkingPrivateVerifyDestinationFunction::Success(bool result) {
    435   results_ = private_api::VerifyDestination::Results::Create(result);
    436   SendResponse(true);
    437 }
    438 
    439 void NetworkingPrivateVerifyDestinationFunction::Failure(
    440     const std::string& error) {
    441   error_ = error;
    442   SendResponse(false);
    443 }
    444 
    445 ////////////////////////////////////////////////////////////////////////////////
    446 // NetworkingPrivateVerifyAndEncryptCredentialsFunction
    447 
    448 NetworkingPrivateVerifyAndEncryptCredentialsFunction::
    449     ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
    450 }
    451 
    452 bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() {
    453   scoped_ptr<private_api::VerifyAndEncryptCredentials::Params> params =
    454       private_api::VerifyAndEncryptCredentials::Params::Create(*args_);
    455   EXTENSION_FUNCTION_VALIDATE(params);
    456 
    457   GetDelegate(browser_context())->VerifyAndEncryptCredentials(
    458       params->network_guid,
    459       params->properties,
    460       base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
    461                  this),
    462       base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
    463                  this));
    464   return true;
    465 }
    466 
    467 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success(
    468     const std::string& result) {
    469   results_ = private_api::VerifyAndEncryptCredentials::Results::Create(result);
    470   SendResponse(true);
    471 }
    472 
    473 void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure(
    474     const std::string& error) {
    475   error_ = error;
    476   SendResponse(false);
    477 }
    478 
    479 ////////////////////////////////////////////////////////////////////////////////
    480 // NetworkingPrivateVerifyAndEncryptDataFunction
    481 
    482 NetworkingPrivateVerifyAndEncryptDataFunction::
    483     ~NetworkingPrivateVerifyAndEncryptDataFunction() {
    484 }
    485 
    486 bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() {
    487   scoped_ptr<private_api::VerifyAndEncryptData::Params> params =
    488       private_api::VerifyAndEncryptData::Params::Create(*args_);
    489   EXTENSION_FUNCTION_VALIDATE(params);
    490 
    491   GetDelegate(browser_context())->VerifyAndEncryptData(
    492       params->properties,
    493       params->data,
    494       base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Success, this),
    495       base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Failure,
    496                  this));
    497   return true;
    498 }
    499 
    500 void NetworkingPrivateVerifyAndEncryptDataFunction::Success(
    501     const std::string& result) {
    502   results_ = private_api::VerifyAndEncryptData::Results::Create(result);
    503   SendResponse(true);
    504 }
    505 
    506 void NetworkingPrivateVerifyAndEncryptDataFunction::Failure(
    507     const std::string& error) {
    508   error_ = error;
    509   SendResponse(false);
    510 }
    511 
    512 ////////////////////////////////////////////////////////////////////////////////
    513 // NetworkingPrivateSetWifiTDLSEnabledStateFunction
    514 
    515 NetworkingPrivateSetWifiTDLSEnabledStateFunction::
    516     ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
    517 }
    518 
    519 bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() {
    520   scoped_ptr<private_api::SetWifiTDLSEnabledState::Params> params =
    521       private_api::SetWifiTDLSEnabledState::Params::Create(*args_);
    522   EXTENSION_FUNCTION_VALIDATE(params);
    523 
    524   GetDelegate(browser_context())->SetWifiTDLSEnabledState(
    525       params->ip_or_mac_address,
    526       params->enabled,
    527       base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success,
    528                  this),
    529       base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure,
    530                  this));
    531 
    532   return true;
    533 }
    534 
    535 void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success(
    536     const std::string& result) {
    537   results_ = private_api::SetWifiTDLSEnabledState::Results::Create(result);
    538   SendResponse(true);
    539 }
    540 
    541 void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure(
    542     const std::string& error) {
    543   error_ = error;
    544   SendResponse(false);
    545 }
    546 
    547 ////////////////////////////////////////////////////////////////////////////////
    548 // NetworkingPrivateGetWifiTDLSStatusFunction
    549 
    550 NetworkingPrivateGetWifiTDLSStatusFunction::
    551     ~NetworkingPrivateGetWifiTDLSStatusFunction() {
    552 }
    553 
    554 bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() {
    555   scoped_ptr<private_api::GetWifiTDLSStatus::Params> params =
    556       private_api::GetWifiTDLSStatus::Params::Create(*args_);
    557   EXTENSION_FUNCTION_VALIDATE(params);
    558 
    559   GetDelegate(browser_context())->GetWifiTDLSStatus(
    560       params->ip_or_mac_address,
    561       base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Success, this),
    562       base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Failure, this));
    563 
    564   return true;
    565 }
    566 
    567 void NetworkingPrivateGetWifiTDLSStatusFunction::Success(
    568     const std::string& result) {
    569   results_ = private_api::GetWifiTDLSStatus::Results::Create(result);
    570   SendResponse(true);
    571 }
    572 
    573 void NetworkingPrivateGetWifiTDLSStatusFunction::Failure(
    574     const std::string& error) {
    575   error_ = error;
    576   SendResponse(false);
    577 }
    578 
    579 ////////////////////////////////////////////////////////////////////////////////
    580 // NetworkingPrivateGetCaptivePortalStatusFunction
    581 
    582 NetworkingPrivateGetCaptivePortalStatusFunction::
    583     ~NetworkingPrivateGetCaptivePortalStatusFunction() {
    584 }
    585 
    586 bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() {
    587   scoped_ptr<private_api::GetCaptivePortalStatus::Params> params =
    588       private_api::GetCaptivePortalStatus::Params::Create(*args_);
    589   EXTENSION_FUNCTION_VALIDATE(params);
    590 
    591   GetDelegate(browser_context())->GetCaptivePortalStatus(
    592       params->network_guid,
    593       base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Success,
    594                  this),
    595       base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Failure,
    596                  this));
    597   return true;
    598 }
    599 
    600 void NetworkingPrivateGetCaptivePortalStatusFunction::Success(
    601     const std::string& result) {
    602   results_ = private_api::GetCaptivePortalStatus::Results::Create(
    603       private_api::ParseCaptivePortalStatus(result));
    604   SendResponse(true);
    605 }
    606 
    607 void NetworkingPrivateGetCaptivePortalStatusFunction::Failure(
    608     const std::string& error) {
    609   error_ = error;
    610   SendResponse(false);
    611 }
    612 
    613 }  // namespace extensions
    614