Add NetworkingPrivateDelegate class

chrome/browser/extensions/api/networking_private/networking_private_api.cc

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
-#include "base/command_line.h"
-#include "base/json/json_reader.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_service_client.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_service_client_factory.h"
-#include "chrome/common/chrome_switches.h"
+#include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
 #include "chrome/common/extensions/api/networking_private.h"
 #include "components/onc/onc_constants.h"
-#include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_registry.h"
-#include "extensions/browser/extension_system.h"
 
-using extensions::NetworkingPrivateServiceClient;
-using extensions::NetworkingPrivateServiceClientFactory;
-namespace api = extensions::api::networking_private;
+namespace {
+
+const int kDefaultNetworkListLimit = 1000;
+
+extensions::NetworkingPrivateDelegate* GetDelegate(
+    content::BrowserContext* browser_context) {
+  return extensions::NetworkingPrivateDelegate::GetForBrowserContext(
+      browser_context);
+}
+
+}  // namespace
+
+namespace private_api = extensions::api::networking_private;
+
+namespace extensions {
+
+namespace networking_private {
+
+// static
+const char kErrorInvalidNetworkGuid[] = "Error.InvalidNetworkGuid";
+const char kErrorNetworkUnavailable[] = "Error.NetworkUnavailable";
+const char kErrorNotReady[] = "Error.NotReady";
+const char kErrorNotSupported[] = "Error.NotSupported";
+
+}  // namespace networking_private
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetPropertiesFunction
 
 NetworkingPrivateGetPropertiesFunction::
-  ~NetworkingPrivateGetPropertiesFunction() {
+    ~NetworkingPrivateGetPropertiesFunction() {
 }
 
 bool NetworkingPrivateGetPropertiesFunction::RunAsync() {
-  scoped_ptr<api::GetProperties::Params> params =
-      api::GetProperties::Params::Create(*args_);
+  scoped_ptr<private_api::GetProperties::Params> params =
+      private_api::GetProperties::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-
-  service_client->GetProperties(
+  GetDelegate(browser_context())->GetProperties(
       params->network_guid,
-      base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess,
-                 this),
-      base::Bind(&NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed,
-                 this));
+      base::Bind(&NetworkingPrivateGetPropertiesFunction::Success, this),
+      base::Bind(&NetworkingPrivateGetPropertiesFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateGetPropertiesFunction::GetPropertiesSuccess(
-    const std::string& network_guid,
-    const base::DictionaryValue& dictionary) {
-  SetResult(dictionary.DeepCopy());
+void NetworkingPrivateGetPropertiesFunction::Success(
+    scoped_ptr<base::DictionaryValue> result) {
+  SetResult(result.release());
   SendResponse(true);
 }
 
-void NetworkingPrivateGetPropertiesFunction::GetPropertiesFailed(
-    const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
+void NetworkingPrivateGetPropertiesFunction::Failure(const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetManagedPropertiesFunction
 
 NetworkingPrivateGetManagedPropertiesFunction::
-  ~NetworkingPrivateGetManagedPropertiesFunction() {
+    ~NetworkingPrivateGetManagedPropertiesFunction() {
 }
 
 bool NetworkingPrivateGetManagedPropertiesFunction::RunAsync() {
-  scoped_ptr<api::GetManagedProperties::Params> params =
-      api::GetManagedProperties::Params::Create(*args_);
+  scoped_ptr<private_api::GetManagedProperties::Params> params =
+      private_api::GetManagedProperties::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
 
-  service_client->GetManagedProperties(
+  GetDelegate(browser_context())->GetManagedProperties(
       params->network_guid,
-      base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success,
-                 this),
+      base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Success, this),
       base::Bind(&NetworkingPrivateGetManagedPropertiesFunction::Failure,
                  this));
   return true;
 }
 
 void NetworkingPrivateGetManagedPropertiesFunction::Success(
-    const std::string& network_guid,
-    const base::DictionaryValue& dictionary) {
-  SetResult(dictionary.DeepCopy());
+    scoped_ptr<base::DictionaryValue> result) {
+  SetResult(result.release());
   SendResponse(true);
 }
 
 void NetworkingPrivateGetManagedPropertiesFunction::Failure(
-    const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
+    const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetStateFunction
 
-NetworkingPrivateGetStateFunction::
-  ~NetworkingPrivateGetStateFunction() {
+NetworkingPrivateGetStateFunction::~NetworkingPrivateGetStateFunction() {
 }
 
 bool NetworkingPrivateGetStateFunction::RunAsync() {
-  scoped_ptr<api::GetState::Params> params =
-      api::GetState::Params::Create(*args_);
+  scoped_ptr<private_api::GetState::Params> params =
+      private_api::GetState::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
 
-  service_client->GetState(
+  GetDelegate(browser_context())->GetState(
       params->network_guid,
-      base::Bind(&NetworkingPrivateGetStateFunction::Success,
-                 this),
-      base::Bind(&NetworkingPrivateGetStateFunction::Failure,
-                 this));
+      base::Bind(&NetworkingPrivateGetStateFunction::Success, this),
+      base::Bind(&NetworkingPrivateGetStateFunction::Failure, this));
   return true;
 }
 
 void NetworkingPrivateGetStateFunction::Success(
-    const std::string& network_guid,
-    const base::DictionaryValue& dictionary) {
-  SetResult(dictionary.DeepCopy());
+    scoped_ptr<base::DictionaryValue> result) {
+  SetResult(result.release());
   SendResponse(true);
 }
 
-void NetworkingPrivateGetStateFunction::Failure(
-    const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
+void NetworkingPrivateGetStateFunction::Failure(const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateSetPropertiesFunction
 
 NetworkingPrivateSetPropertiesFunction::
-  ~NetworkingPrivateSetPropertiesFunction() {
+    ~NetworkingPrivateSetPropertiesFunction() {
 }
 
 bool NetworkingPrivateSetPropertiesFunction::RunAsync() {
-  scoped_ptr<api::SetProperties::Params> params =
-      api::SetProperties::Params::Create(*args_);
+  scoped_ptr<private_api::SetProperties::Params> params =
+      private_api::SetProperties::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
+
   scoped_ptr<base::DictionaryValue> properties_dict(
       params->properties.ToValue());
 
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-
-  service_client->SetProperties(
+  GetDelegate(browser_context())->SetProperties(
       params->network_guid,
-      *properties_dict,
-      base::Bind(&NetworkingPrivateSetPropertiesFunction::ResultCallback, this),
-      base::Bind(&NetworkingPrivateSetPropertiesFunction::ErrorCallback, this));
+      properties_dict.Pass(),
+      base::Bind(&NetworkingPrivateSetPropertiesFunction::Success, this),
+      base::Bind(&NetworkingPrivateSetPropertiesFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateSetPropertiesFunction::ResultCallback() {
+void NetworkingPrivateSetPropertiesFunction::Success() {
   SendResponse(true);
 }
 
-void NetworkingPrivateSetPropertiesFunction::ErrorCallback(
-    const std::string& error_name,
-    const scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
+void NetworkingPrivateSetPropertiesFunction::Failure(const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateCreateNetworkFunction
 
 NetworkingPrivateCreateNetworkFunction::
-~NetworkingPrivateCreateNetworkFunction() {
+    ~NetworkingPrivateCreateNetworkFunction() {
 }
 
 bool NetworkingPrivateCreateNetworkFunction::RunAsync() {
-  scoped_ptr<api::CreateNetwork::Params> params =
-      api::CreateNetwork::Params::Create(*args_);
+  scoped_ptr<private_api::CreateNetwork::Params> params =
+      private_api::CreateNetwork::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
+
   scoped_ptr<base::DictionaryValue> properties_dict(
       params->properties.ToValue());
 
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-
-  service_client->CreateNetwork(
+  GetDelegate(browser_context())->CreateNetwork(
       params->shared,
-      *properties_dict,
-      base::Bind(&NetworkingPrivateCreateNetworkFunction::ResultCallback, this),
-      base::Bind(&NetworkingPrivateCreateNetworkFunction::ErrorCallback, this));
+      properties_dict.Pass(),
+      base::Bind(&NetworkingPrivateCreateNetworkFunction::Success, this),
+      base::Bind(&NetworkingPrivateCreateNetworkFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateCreateNetworkFunction::ErrorCallback(
-    const std::string& error_name,
-    const scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
-  SendResponse(false);
+void NetworkingPrivateCreateNetworkFunction::Success(const std::string& guid) {
+  results_ = private_api::CreateNetwork::Results::Create(guid);
+  SendResponse(true);
 }
 
-void NetworkingPrivateCreateNetworkFunction::ResultCallback(
-    const std::string& guid) {
-  results_ = api::CreateNetwork::Results::Create(guid);
-  SendResponse(true);
+void NetworkingPrivateCreateNetworkFunction::Failure(const std::string& error) {
+  error_ = error;
+  SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetNetworksFunction
 
-NetworkingPrivateGetNetworksFunction::
-  ~NetworkingPrivateGetNetworksFunction() {
+NetworkingPrivateGetNetworksFunction::~NetworkingPrivateGetNetworksFunction() {
 }
 
 bool NetworkingPrivateGetNetworksFunction::RunAsync() {
-  scoped_ptr<api::GetNetworks::Params> params =
-      api::GetNetworks::Params::Create(*args_);
+  scoped_ptr<private_api::GetNetworks::Params> params =
+      private_api::GetNetworks::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  // TODO(stevenjb/mef): Apply filters (visible, configured).
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
+  std::string network_type = private_api::ToString(params->filter.network_type);
+  const bool configured_only =
+      params->filter.configured ? *params->filter.configured : false;
+  const bool visible_only =
+      params->filter.visible ? *params->filter.visible : false;
+  const int limit =
+      params->filter.limit ? *params->filter.limit : kDefaultNetworkListLimit;
 
-  service_client->GetVisibleNetworks(
-      api::ToString(params->filter.network_type),
-      base::Bind(&NetworkingPrivateGetNetworksFunction::ResultCallback, this));
-
+  GetDelegate(browser_context())->GetNetworks(
+      network_type,
+      configured_only,
+      visible_only,
+      limit,
+      base::Bind(&NetworkingPrivateGetNetworksFunction::Success, this),
+      base::Bind(&NetworkingPrivateGetNetworksFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateGetNetworksFunction::ResultCallback(
-    const base::ListValue& network_list) {
-  SetResult(network_list.DeepCopy());
+void NetworkingPrivateGetNetworksFunction::Success(
+    scoped_ptr<base::ListValue> network_list) {
+  SetResult(network_list.release());
   SendResponse(true);
 }
 
+void NetworkingPrivateGetNetworksFunction::Failure(const std::string& error) {
+  error_ = error;
+  SendResponse(false);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetVisibleNetworksFunction
 
 NetworkingPrivateGetVisibleNetworksFunction::
-  ~NetworkingPrivateGetVisibleNetworksFunction() {
+    ~NetworkingPrivateGetVisibleNetworksFunction() {
 }
 
 bool NetworkingPrivateGetVisibleNetworksFunction::RunAsync() {
-  scoped_ptr<api::GetVisibleNetworks::Params> params =
-      api::GetVisibleNetworks::Params::Create(*args_);
+  scoped_ptr<private_api::GetVisibleNetworks::Params> params =
+      private_api::GetVisibleNetworks::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
+  std::string network_type = private_api::ToString(params->network_type);
+  const bool configured_only = false;
+  const bool visible_only = true;
 
-  service_client->GetVisibleNetworks(
-      api::ToString(params->network_type),
-      base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::ResultCallback,
-                 this));
-
+  GetDelegate(browser_context())->GetNetworks(
+      network_type,
+      configured_only,
+      visible_only,
+      kDefaultNetworkListLimit,
+      base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Success, this),
+      base::Bind(&NetworkingPrivateGetVisibleNetworksFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateGetVisibleNetworksFunction::ResultCallback(
-    const base::ListValue& network_list) {
-  SetResult(network_list.DeepCopy());
+void NetworkingPrivateGetVisibleNetworksFunction::Success(
+    scoped_ptr<base::ListValue> network_properties_list) {
+  SetResult(network_properties_list.release());
   SendResponse(true);
 }
 
+void NetworkingPrivateGetVisibleNetworksFunction::Failure(
+    const std::string& error) {
+  error_ = error;
+  SendResponse(false);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetEnabledNetworkTypesFunction
 
 NetworkingPrivateGetEnabledNetworkTypesFunction::
-~NetworkingPrivateGetEnabledNetworkTypesFunction() {
+    ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
 }
 
 bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
-  base::ListValue* network_list = new base::ListValue;
-  network_list->Append(new base::StringValue(onc::network_type::kWiFi));
-  SetResult(network_list);
+  scoped_ptr<base::ListValue> enabled_networks_onc_types(
+      GetDelegate(browser_context())->GetEnabledNetworkTypes());
+  if (!enabled_networks_onc_types) {
+    error_ = networking_private::kErrorNotSupported;
+    return false;
+  }
+  scoped_ptr<base::ListValue> enabled_networks_list;
+  for (base::ListValue::iterator iter = enabled_networks_onc_types->begin();
+       iter != enabled_networks_onc_types->end(); ++iter) {
+    std::string type;
+    if (!(*iter)->GetAsString(&type))
+      NOTREACHED();
+    if (type == ::onc::network_type::kEthernet) {
+      enabled_networks_list->AppendString(api::networking_private::ToString(
+          api::networking_private::NETWORK_TYPE_ETHERNET));
+    } else if (type == ::onc::network_type::kWiFi) {
+      enabled_networks_list->AppendString(api::networking_private::ToString(
+          api::networking_private::NETWORK_TYPE_WIFI));
+    } else if (type == ::onc::network_type::kWimax) {
+      enabled_networks_list->AppendString(api::networking_private::ToString(
+          api::networking_private::NETWORK_TYPE_WIMAX));
+    } else if (type == ::onc::network_type::kCellular) {
+      enabled_networks_list->AppendString(api::networking_private::ToString(
+          api::networking_private::NETWORK_TYPE_CELLULAR));
+    } else {
+      LOG(ERROR) << "networkingPrivate: Unexpected type: " << type;
+    }
+  }
+  SetResult(enabled_networks_list.release());
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateEnableNetworkTypeFunction
 
 NetworkingPrivateEnableNetworkTypeFunction::
-~NetworkingPrivateEnableNetworkTypeFunction() {
+    ~NetworkingPrivateEnableNetworkTypeFunction() {
 }
 
 bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
-  scoped_ptr<api::EnableNetworkType::Params> params =
-      api::EnableNetworkType::Params::Create(*args_);
+  scoped_ptr<private_api::EnableNetworkType::Params> params =
+      private_api::EnableNetworkType::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  return true;
+
+  return GetDelegate(browser_context())->EnableNetworkType(
+      private_api::ToString(params->network_type));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateDisableNetworkTypeFunction
 
 NetworkingPrivateDisableNetworkTypeFunction::
-~NetworkingPrivateDisableNetworkTypeFunction() {
+    ~NetworkingPrivateDisableNetworkTypeFunction() {
 }
 
 bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
-  scoped_ptr<api::DisableNetworkType::Params> params =
-      api::DisableNetworkType::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(params);
-  return true;
+  scoped_ptr<private_api::DisableNetworkType::Params> params =
+      private_api::DisableNetworkType::Params::Create(*args_);
+
+  return GetDelegate(browser_context())->DisableNetworkType(
+      private_api::ToString(params->network_type));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateRequestNetworkScanFunction
 
 NetworkingPrivateRequestNetworkScanFunction::
-  ~NetworkingPrivateRequestNetworkScanFunction() {
+    ~NetworkingPrivateRequestNetworkScanFunction() {
 }
 
 bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-  service_client->RequestNetworkScan();
-  return true;
+  return GetDelegate(browser_context())->RequestScan();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateStartConnectFunction
 
 NetworkingPrivateStartConnectFunction::
-  ~NetworkingPrivateStartConnectFunction() {
+    ~NetworkingPrivateStartConnectFunction() {
 }
 
 bool NetworkingPrivateStartConnectFunction::RunAsync() {
-  scoped_ptr<api::StartConnect::Params> params =
-      api::StartConnect::Params::Create(*args_);
+  scoped_ptr<private_api::StartConnect::Params> params =
+      private_api::StartConnect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-  service_client->StartConnect(
+
+  GetDelegate(browser_context())->StartConnect(
       params->network_guid,
-      base::Bind(&NetworkingPrivateStartConnectFunction::ConnectionStartSuccess,
-                 this),
-      base::Bind(&NetworkingPrivateStartConnectFunction::ConnectionStartFailed,
-                 this));
+      base::Bind(&NetworkingPrivateStartConnectFunction::Success, this),
+      base::Bind(&NetworkingPrivateStartConnectFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateStartConnectFunction::ConnectionStartSuccess() {
+void NetworkingPrivateStartConnectFunction::Success() {
   SendResponse(true);
 }
 
-void NetworkingPrivateStartConnectFunction::ConnectionStartFailed(
-    const std::string& error_name,
-    const scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
+void NetworkingPrivateStartConnectFunction::Failure(const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateStartDisconnectFunction
 
 NetworkingPrivateStartDisconnectFunction::
-  ~NetworkingPrivateStartDisconnectFunction() {
+    ~NetworkingPrivateStartDisconnectFunction() {
 }
 
 bool NetworkingPrivateStartDisconnectFunction::RunAsync() {
-  scoped_ptr<api::StartDisconnect::Params> params =
-      api::StartDisconnect::Params::Create(*args_);
+  scoped_ptr<private_api::StartDisconnect::Params> params =
+      private_api::StartDisconnect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-  service_client->StartDisconnect(
+
+  GetDelegate(browser_context())->StartDisconnect(
       params->network_guid,
-      base::Bind(
-          &NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess,
-          this),
-      base::Bind(
-          &NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed,
-          this));
+      base::Bind(&NetworkingPrivateStartDisconnectFunction::Success, this),
+      base::Bind(&NetworkingPrivateStartDisconnectFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateStartDisconnectFunction::DisconnectionStartSuccess() {
+void NetworkingPrivateStartDisconnectFunction::Success() {
   SendResponse(true);
 }
 
-void NetworkingPrivateStartDisconnectFunction::DisconnectionStartFailed(
-    const std::string& error_name,
-    const scoped_ptr<base::DictionaryValue> error_data) {
-  error_ = error_name;
+void NetworkingPrivateStartDisconnectFunction::Failure(
+    const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateVerifyDestinationFunction
 
 NetworkingPrivateVerifyDestinationFunction::
-    ~NetworkingPrivateVerifyDestinationFunction() {}
+    ~NetworkingPrivateVerifyDestinationFunction() {
+}
 
 bool NetworkingPrivateVerifyDestinationFunction::RunAsync() {
-  scoped_ptr<api::VerifyDestination::Params> params =
-      api::VerifyDestination::Params::Create(*args_);
+  scoped_ptr<private_api::VerifyDestination::Params> params =
+      private_api::VerifyDestination::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-  service_client->VerifyDestination(
-      args_.Pass(),
-      base::Bind(
-          &NetworkingPrivateVerifyDestinationFunction::ResultCallback,
-          this),
-      base::Bind(
-          &NetworkingPrivateVerifyDestinationFunction::ErrorCallback,
-          this));
+
+  GetDelegate(browser_context())->VerifyDestination(
+      params->properties,
+      base::Bind(&NetworkingPrivateVerifyDestinationFunction::Success, this),
+      base::Bind(&NetworkingPrivateVerifyDestinationFunction::Failure, this));
   return true;
 }
 
-void NetworkingPrivateVerifyDestinationFunction::ResultCallback(bool result) {
-  SetResult(new base::FundamentalValue(result));
+void NetworkingPrivateVerifyDestinationFunction::Success(bool result) {
+  results_ = private_api::VerifyDestination::Results::Create(result);
   SendResponse(true);
 }
 
-void NetworkingPrivateVerifyDestinationFunction::ErrorCallback(
-    const std::string& error_name, const std::string& error) {
-  error_ = error_name;
+void NetworkingPrivateVerifyDestinationFunction::Failure(
+    const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateVerifyAndEncryptCredentialsFunction
 
 NetworkingPrivateVerifyAndEncryptCredentialsFunction::
-  ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
+    ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
 }
 
 bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunAsync() {
-  scoped_ptr<api::VerifyAndEncryptCredentials::Params> params =
-      api::VerifyAndEncryptCredentials::Params::Create(*args_);
+  scoped_ptr<private_api::VerifyAndEncryptCredentials::Params> params =
+      private_api::VerifyAndEncryptCredentials::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-  service_client->VerifyAndEncryptCredentials(
-      args_.Pass(),
-      base::Bind(
-          &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback,
-          this),
-      base::Bind(
-          &NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback,
-          this));
+
+  GetDelegate(browser_context())->VerifyAndEncryptCredentials(
+      params->network_guid,
+      params->properties,
+      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
+                 this),
+      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
+                 this));
   return true;
 }
 
-void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ResultCallback(
+void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success(
     const std::string& result) {
-  SetResult(new base::StringValue(result));
+  results_ = private_api::VerifyAndEncryptCredentials::Results::Create(result);
   SendResponse(true);
 }
 
-void NetworkingPrivateVerifyAndEncryptCredentialsFunction::ErrorCallback(
-    const std::string& error_name,
+void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure(
     const std::string& error) {
-  error_ = error_name;
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateVerifyAndEncryptDataFunction
 
 NetworkingPrivateVerifyAndEncryptDataFunction::
-  ~NetworkingPrivateVerifyAndEncryptDataFunction() {
+    ~NetworkingPrivateVerifyAndEncryptDataFunction() {
 }
 
 bool NetworkingPrivateVerifyAndEncryptDataFunction::RunAsync() {
-  scoped_ptr<api::VerifyAndEncryptData::Params> params =
-      api::VerifyAndEncryptData::Params::Create(*args_);
+  scoped_ptr<private_api::VerifyAndEncryptData::Params> params =
+      private_api::VerifyAndEncryptData::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  NetworkingPrivateServiceClient* service_client =
-      NetworkingPrivateServiceClientFactory::GetForProfile(GetProfile());
-  service_client->VerifyAndEncryptData(
-      args_.Pass(),
-      base::Bind(
-          &NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback,
-          this),
-      base::Bind(
-          &NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback,
-          this));
+
+  GetDelegate(browser_context())->VerifyAndEncryptData(
+      params->properties,
+      params->data,
+      base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Success, this),
+      base::Bind(&NetworkingPrivateVerifyAndEncryptDataFunction::Failure,
+                 this));
   return true;
 }
 
-void NetworkingPrivateVerifyAndEncryptDataFunction::ResultCallback(
+void NetworkingPrivateVerifyAndEncryptDataFunction::Success(
     const std::string& result) {
-  SetResult(new base::StringValue(result));
+  results_ = private_api::VerifyAndEncryptData::Results::Create(result);
   SendResponse(true);
 }
 
-void NetworkingPrivateVerifyAndEncryptDataFunction::ErrorCallback(
-    const std::string& error_name, const std::string& error) {
-  error_ = error_name;
+void NetworkingPrivateVerifyAndEncryptDataFunction::Failure(
+    const std::string& error) {
+  error_ = error;
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateSetWifiTDLSEnabledStateFunction
 
 NetworkingPrivateSetWifiTDLSEnabledStateFunction::
-  ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
+    ~NetworkingPrivateSetWifiTDLSEnabledStateFunction() {
 }
 
 bool NetworkingPrivateSetWifiTDLSEnabledStateFunction::RunAsync() {
-  scoped_ptr<api::SetWifiTDLSEnabledState::Params> params =
-      api::SetWifiTDLSEnabledState::Params::Create(*args_);
+  scoped_ptr<private_api::SetWifiTDLSEnabledState::Params> params =
+      private_api::SetWifiTDLSEnabledState::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  SetError("not-implemented");
-  return false;
+
+  GetDelegate(browser_context())->SetWifiTDLSEnabledState(
+      params->ip_or_mac_address,
+      params->enabled,
+      base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success,
+                 this),
+      base::Bind(&NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure,
+                 this));
+
+  return true;
+}
+
+void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Success(
+    const std::string& result) {
+  results_ = private_api::SetWifiTDLSEnabledState::Results::Create(result);
+  SendResponse(true);
+}
+
+void NetworkingPrivateSetWifiTDLSEnabledStateFunction::Failure(
+    const std::string& error) {
+  error_ = error;
+  SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetWifiTDLSStatusFunction
 
 NetworkingPrivateGetWifiTDLSStatusFunction::
-  ~NetworkingPrivateGetWifiTDLSStatusFunction() {
+    ~NetworkingPrivateGetWifiTDLSStatusFunction() {
 }
 
 bool NetworkingPrivateGetWifiTDLSStatusFunction::RunAsync() {
-  scoped_ptr<api::GetWifiTDLSStatus::Params> params =
-      api::GetWifiTDLSStatus::Params::Create(*args_);
+  scoped_ptr<private_api::GetWifiTDLSStatus::Params> params =
+      private_api::GetWifiTDLSStatus::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  SetError("not-implemented");
-  return false;
+
+  GetDelegate(browser_context())->GetWifiTDLSStatus(
+      params->ip_or_mac_address,
+      base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Success, this),
+      base::Bind(&NetworkingPrivateGetWifiTDLSStatusFunction::Failure, this));
+
+  return true;
+}
+
+void NetworkingPrivateGetWifiTDLSStatusFunction::Success(
+    const std::string& result) {
+  results_ = private_api::GetWifiTDLSStatus::Results::Create(result);
+  SendResponse(true);
+}
+
+void NetworkingPrivateGetWifiTDLSStatusFunction::Failure(
+    const std::string& error) {
+  error_ = error;
+  SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetCaptivePortalStatusFunction
 
 NetworkingPrivateGetCaptivePortalStatusFunction::
-    ~NetworkingPrivateGetCaptivePortalStatusFunction() {}
+    ~NetworkingPrivateGetCaptivePortalStatusFunction() {
+}
 
 bool NetworkingPrivateGetCaptivePortalStatusFunction::RunAsync() {
-  scoped_ptr<api::GetCaptivePortalStatus::Params> params =
-      api::GetCaptivePortalStatus::Params::Create(*args_);
+  scoped_ptr<private_api::GetCaptivePortalStatus::Params> params =
+      private_api::GetCaptivePortalStatus::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  SetError("not-implemented");
-  return false;
+
+  GetDelegate(browser_context())->GetCaptivePortalStatus(
+      params->network_guid,
+      base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Success,
+                 this),
+      base::Bind(&NetworkingPrivateGetCaptivePortalStatusFunction::Failure,
+                 this));
+  return true;
 }
+
+void NetworkingPrivateGetCaptivePortalStatusFunction::Success(
+    const std::string& result) {
+  results_ = private_api::GetCaptivePortalStatus::Results::Create(
+      private_api::ParseCaptivePortalStatus(result));
+  SendResponse(true);
+}
+
+void NetworkingPrivateGetCaptivePortalStatusFunction::Failure(
+    const std::string& error) {
+  error_ = error;
+  SendResponse(false);
+}
+
+}  // namespace extensions