Added support for multiple parameters to Extension API callbacks.

chrome/browser/extensions/api/bluetooth/bluetooth_api.cc

 // Copyright (c) 2012 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/bluetooth/bluetooth_api.h"
 
 #if defined(OS_CHROMEOS)
 #include <errno.h>
 #endif
 
@@ skipping 55 matching lines @@
 namespace SetOutOfBandPairingData =
     extensions::api::experimental_bluetooth::SetOutOfBandPairingData;
 namespace Write = extensions::api::experimental_bluetooth::Write;
 
 namespace extensions {
 namespace api {
 
 #if defined(OS_CHROMEOS)
 
 bool BluetoothIsAvailableFunction::RunImpl() {
-  result_.reset(Value::CreateBooleanValue(GetAdapter(profile())->IsPresent()));
+  SetResult(Value::CreateBooleanValue(GetAdapter(profile())->IsPresent()));
   return true;
 }
 
 bool BluetoothIsPoweredFunction::RunImpl() {
-  result_.reset(Value::CreateBooleanValue(GetAdapter(profile())->IsPowered()));
+  SetResult(Value::CreateBooleanValue(GetAdapter(profile())->IsPowered()));
   return true;
 }
 
 bool BluetoothGetAddressFunction::RunImpl() {
-  result_.reset(Value::CreateStringValue(GetAdapter(profile())->address()));
+  SetResult(Value::CreateStringValue(GetAdapter(profile())->address()));
   return true;
 }
 
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : callbacks_pending_(0) {}
 
 void BluetoothGetDevicesFunction::AddDeviceIfTrueCallback(
     ListValue* list,
     const chromeos::BluetoothDevice* device,
     bool shouldAdd) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (shouldAdd)
     list->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
 
   callbacks_pending_--;
   if (callbacks_pending_ == -1)
     SendResponse(true);
 }
 
 bool BluetoothGetDevicesFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::GetDevicesOptions& options = params->options;
 
   ListValue* matches = new ListValue;
-  result_.reset(matches);
+  SetResult(matches);
 
   CHECK_EQ(0, callbacks_pending_);
 
   chromeos::BluetoothAdapter::DeviceList devices =
       GetMutableAdapter(profile())->GetDevices();
   for (chromeos::BluetoothAdapter::DeviceList::iterator i = devices.begin();
       i != devices.end(); ++i) {
     chromeos::BluetoothDevice* device = *i;
 
     if (options.uuid.get() != NULL &&
@@ skipping 52 matching lines @@
 
   chromeos::BluetoothDevice* device =
       GetMutableAdapter(profile())->GetDevice(options.device_address);
   if (!device) {
     SendResponse(false);
     SetError(kInvalidDevice);
     return false;
   }
 
   ListValue* services = new ListValue;
-  result_.reset(services);
+  SetResult(services);
 
   device->GetServiceRecords(
       base::Bind(&BluetoothGetServicesFunction::GetServiceRecordsCallback,
                  this,
                  services),
       base::Bind(&BluetoothGetServicesFunction::OnErrorCallback,
                  this));
 
   return true;
 }
 
 void BluetoothConnectFunction::ConnectToServiceCallback(
     const chromeos::BluetoothDevice* device,
     const std::string& service_uuid,
     scoped_refptr<chromeos::BluetoothSocket> socket) {
   if (socket.get()) {
     int socket_id = GetEventRouter(profile())->RegisterSocket(socket);
 
     experimental_bluetooth::Socket result_socket;
     experimental_bluetooth::BluetoothDeviceToApiDevice(
         *device, &result_socket.device);
     result_socket.service_uuid = service_uuid;
     result_socket.id = socket_id;
-    result_.reset(result_socket.ToValue().release());
+    SetResult(result_socket.ToValue().release());
     SendResponse(true);
   } else {
     SetError(kFailedToConnect);
     SendResponse(false);
   }
 }
 
 bool BluetoothConnectFunction::RunImpl() {
   scoped_ptr<Connect::Params> params(Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
@@ skipping 55 matching lines @@
         buffer_size - total_bytes_read);
     errsv = errno;
     if (bytes_read <= 0)
       break;
 
     total_bytes_read += bytes_read;
   }
 
   if (total_bytes_read > 0) {
     success_ = true;
-    result_.reset(base::BinaryValue::Create(all_bytes, total_bytes_read));
+    SetResult(base::BinaryValue::Create(all_bytes, total_bytes_read));
   } else {
     success_ = (errsv == EAGAIN || errsv == EWOULDBLOCK);
     free(all_bytes);
   }
 
   if (!success_)
     SetError(safe_strerror(errsv));
 }
 
 bool BluetoothReadFunction::Respond() {
@@ skipping 26 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   if (socket_.get() == NULL)
     return;
 
   ssize_t bytes_written = write(socket_->fd(),
       data_to_write_->GetBuffer(), data_to_write_->GetSize());
   int errsv = errno;
 
   if (bytes_written > 0) {
-    result_.reset(Value::CreateIntegerValue(bytes_written));
+    SetResult(Value::CreateIntegerValue(bytes_written));
     success_ = true;
   } else {
-    result_.reset(0);
+    results_.reset();
     success_ = (errsv == EAGAIN || errsv == EWOULDBLOCK);
   }
 
   if (!success_)
     SetError(safe_strerror(errsv));
 }
 
 bool BluetoothWriteFunction::Respond() {
   return success_;
 }
@@ skipping 69 matching lines @@
   base::BinaryValue* randomizer = base::BinaryValue::CreateWithCopiedBuffer(
       reinterpret_cast<const char*>(data.randomizer),
       chromeos::kBluetoothOutOfBandPairingDataSize);
 
   // TODO(bryeung): convert to experimental_bluetooth::OutOfBandPairingData
   // when ArrayBuffer support within objects is completed.
   DictionaryValue* result = new DictionaryValue();
   result->Set("hash", hash);
   result->Set("randomizer", randomizer);
 
-  result_.reset(result);
+  SetResult(result);
 
   SendResponse(true);
 }
 
 void BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback() {
   SetError(kCouldNotGetLocalOutOfBandPairingData);
   SendResponse(false);
 }
 
 bool BluetoothGetLocalOutOfBandPairingDataFunction::RunImpl() {
@@ skipping 134 matching lines @@
 #endif
 
 BluetoothReadFunction::BluetoothReadFunction() {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 BluetoothWriteFunction::BluetoothWriteFunction() {}
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 }  // namespace api
 }  // namespace extensions