[Extensions] Convert some SyncExtensionFunctions

extensions/browser/api/networking_private/networking_private_api.cc

 // 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 "extensions/browser/api/networking_private/networking_private_api.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 297 matching lines @@
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetEnabledNetworkTypesFunction
 
 NetworkingPrivateGetEnabledNetworkTypesFunction::
     ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
 }
 
-bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateGetEnabledNetworkTypesFunction::Run() {
   std::unique_ptr<base::ListValue> enabled_networks_onc_types(
       GetDelegate(browser_context())->GetEnabledNetworkTypes());
-  if (!enabled_networks_onc_types) {
-    error_ = networking_private::kErrorNotSupported;
-    return false;
-  }
+  if (!enabled_networks_onc_types)
+    return RespondNow(Error(networking_private::kErrorNotSupported));
   std::unique_ptr<base::ListValue> enabled_networks_list(new base::ListValue);
   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(
           private_api::ToString(private_api::NETWORK_TYPE_ETHERNET));
     } else if (type == ::onc::network_type::kWiFi) {
       enabled_networks_list->AppendString(
           private_api::ToString(private_api::NETWORK_TYPE_WIFI));
     } else if (type == ::onc::network_type::kWimax) {
       enabled_networks_list->AppendString(
           private_api::ToString(private_api::NETWORK_TYPE_WIMAX));
     } else if (type == ::onc::network_type::kCellular) {
       enabled_networks_list->AppendString(
           private_api::ToString(private_api::NETWORK_TYPE_CELLULAR));
     } else {
       LOG(ERROR) << "networkingPrivate: Unexpected type: " << type;
     }
   }
-  SetResult(std::move(enabled_networks_list));
-  return true;
+  return RespondNow(OneArgument(std::move(enabled_networks_list)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateGetDeviceStatesFunction
 
 NetworkingPrivateGetDeviceStatesFunction::
     ~NetworkingPrivateGetDeviceStatesFunction() {
 }
 
-bool NetworkingPrivateGetDeviceStatesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateGetDeviceStatesFunction::Run() {
   std::unique_ptr<NetworkingPrivateDelegate::DeviceStateList> device_states(
       GetDelegate(browser_context())->GetDeviceStateList());
-  if (!device_states) {
-    error_ = networking_private::kErrorNotSupported;
-    return false;
-  }
+  if (!device_states)
+    return RespondNow(Error(networking_private::kErrorNotSupported));
 
   std::unique_ptr<base::ListValue> device_state_list(new base::ListValue);
   for (const auto& properties : *device_states)
     device_state_list->Append(properties->ToValue());
-  SetResult(std::move(device_state_list));
-  return true;
+  return RespondNow(OneArgument(std::move(device_state_list)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateEnableNetworkTypeFunction
 
 NetworkingPrivateEnableNetworkTypeFunction::
     ~NetworkingPrivateEnableNetworkTypeFunction() {
 }
 
-bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateEnableNetworkTypeFunction::Run() {
   std::unique_ptr<private_api::EnableNetworkType::Params> params =
       private_api::EnableNetworkType::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  return GetDelegate(browser_context())
-      ->EnableNetworkType(private_api::ToString(params->network_type));
+  if (!GetDelegate(browser_context())
+           ->EnableNetworkType(private_api::ToString(params->network_type))) {
+    return RespondNow(Error(networking_private::kErrorNotSupported));
+  }
+  return RespondNow(NoArguments());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateDisableNetworkTypeFunction
 
 NetworkingPrivateDisableNetworkTypeFunction::
     ~NetworkingPrivateDisableNetworkTypeFunction() {
 }
 
-bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateDisableNetworkTypeFunction::Run() {
   std::unique_ptr<private_api::DisableNetworkType::Params> params =
       private_api::DisableNetworkType::Params::Create(*args_);
 
-  return GetDelegate(browser_context())
-      ->DisableNetworkType(private_api::ToString(params->network_type));
+  if (!GetDelegate(browser_context())
+           ->DisableNetworkType(private_api::ToString(params->network_type))) {
+    return RespondNow(Error(networking_private::kErrorNotSupported));
+  }
+  return RespondNow(NoArguments());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateRequestNetworkScanFunction
 
 NetworkingPrivateRequestNetworkScanFunction::
     ~NetworkingPrivateRequestNetworkScanFunction() {
 }
 
-bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
-  return GetDelegate(browser_context())->RequestScan();
+ExtensionFunction::ResponseAction
+NetworkingPrivateRequestNetworkScanFunction::Run() {
+  if (!GetDelegate(browser_context())->RequestScan())
+    return RespondNow(Error(networking_private::kErrorNotSupported));
+  return RespondNow(NoArguments());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateStartConnectFunction
 
 NetworkingPrivateStartConnectFunction::
     ~NetworkingPrivateStartConnectFunction() {
 }
 
 bool NetworkingPrivateStartConnectFunction::RunAsync() {
@@ skipping 343 matching lines @@
   SendResponse(true);
 }
 
 void NetworkingPrivateSetCellularSimStateFunction::Failure(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
 }
 
 }  // namespace extensions