Added support for multiple parameters to Extension API callbacks.

chrome/browser/extensions/api/socket/socket_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/socket/socket_api.h"
 
 #include "base/bind.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/api_resource_controller.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
@@ skipping 102 matching lines @@
   Socket* socket = NULL;
   if (socket_type_ == kSocketTypeTCP) {
     socket = new TCPSocket(event_notifier_);
   } else if (socket_type_== kSocketTypeUDP) {
     socket = new UDPSocket(event_notifier_);
   }
   DCHECK(socket);
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kSocketIdKey, controller()->AddAPIResource(socket));
-  result_.reset(result);
+  SetSingleResult(result);
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDestroyFunction::Work() {
   if (!controller()->RemoveSocket(socket_id_))
     error_ = kSocketNotFoundError;
@@ skipping 13 matching lines @@
 }
 
 void SocketConnectFunction::AsyncWorkStart() {
   StartDnsLookup(hostname_);
 }
 
 void SocketConnectFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartConnect();
   } else {
-    result_.reset(Value::CreateIntegerValue(lookup_result));
+    SetSingleResult(Value::CreateIntegerValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketConnectFunction::StartConnect() {
   Socket* socket = controller()->GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnConnect(-1);
     return;
   }
 
   socket->Connect(resolved_address_, port_,
                   base::Bind(&SocketConnectFunction::OnConnect, this));
 }
 
 void SocketConnectFunction::OnConnect(int result) {
-  result_.reset(Value::CreateIntegerValue(result));
+  SetSingleResult(Value::CreateIntegerValue(result));
   AsyncWorkCompleted();
 }
 
 bool SocketDisconnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDisconnectFunction::Work() {
   Socket* socket = controller()->GetSocket(socket_id_);
   if (socket)
     socket->Disconnect();
   else
     error_ = kSocketNotFoundError;
-  result_.reset(Value::CreateNullValue());
+  SetSingleResult(Value::CreateNullValue());
 }
 
 bool SocketBindFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &address_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketBindFunction::Work() {
   int result = -1;
   Socket* socket = controller()->GetSocket(socket_id_);
   if (socket)
     result = socket->Bind(address_, port_);
   else
     error_ = kSocketNotFoundError;
 
-  result_.reset(Value::CreateIntegerValue(result));
+  SetSingleResult(Value::CreateIntegerValue(result));
 }
 
 SocketReadFunction::SocketReadFunction()
     : params_(NULL) {
 }
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
   params_ = api::experimental_socket::Read::Params::Create(*args_);
@@ skipping 19 matching lines @@
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     // BinaryValue does not support NULL buffer. Workaround it with new char[1].
     // http://crbug.com/127630
     result->Set(kDataKey, base::BinaryValue::Create(new char[1], 0));
   }
-  result_.reset(result);
+  SetSingleResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketWriteFunction::SocketWriteFunction()
     : socket_id_(0),
       io_buffer_(NULL),
       io_buffer_size_(0) {
 }
 
@@ skipping 18 matching lines @@
     return;
   }
 
   socket->Write(io_buffer_, io_buffer_size_,
                 base::Bind(&SocketWriteFunction::OnCompleted, this));
 }
 
 void SocketWriteFunction::OnCompleted(int bytes_written) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
-  result_.reset(result);
+  SetSingleResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketRecvFromFunction::SocketRecvFromFunction()
     : params_(NULL) {
 }
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
@@ skipping 25 matching lines @@
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     // BinaryValue does not support NULL buffer. Workaround it with new char[1].
     // http://crbug.com/127630
     result->Set(kDataKey, base::BinaryValue::Create(new char[1], 0));
   }
   result->SetString(kAddressKey, address);
   result->SetInteger(kPortKey, port);
-  result_.reset(result);
+  SetSingleResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketSendToFunction::SocketSendToFunction()
     : socket_id_(0),
       io_buffer_(NULL),
       io_buffer_size_(0) {
 }
 
@@ skipping 12 matching lines @@
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
   StartDnsLookup(hostname_);
 }
 
 void SocketSendToFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartSendTo();
   } else {
-    result_.reset(Value::CreateIntegerValue(lookup_result));
+    SetSingleResult(Value::CreateIntegerValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketSendToFunction::StartSendTo() {
   Socket* socket = controller()->GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1);
     return;
   }
 
   socket->SendTo(io_buffer_, io_buffer_size_, resolved_address_, port_,
                  base::Bind(&SocketSendToFunction::OnCompleted, this));
 }
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
-  result_.reset(result);
+  SetSingleResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketSetKeepAliveFunction::SocketSetKeepAliveFunction()
     : params_(NULL) {
 }
 
 SocketSetKeepAliveFunction::~SocketSetKeepAliveFunction() {}
 
 bool SocketSetKeepAliveFunction::Prepare() {
   params_ = api::experimental_socket::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetKeepAliveFunction::Work() {
   bool result = false;
   Socket* socket = controller()->GetSocket(params_->socket_id);
   if (socket) {
     int delay = 0;
     if (params_->delay.get())
       delay = *params_->delay;
     result = socket->SetKeepAlive(params_->enable, delay);
   } else {
     error_ = kSocketNotFoundError;
   }
-  result_.reset(Value::CreateBooleanValue(result));
+  SetSingleResult(Value::CreateBooleanValue(result));
 }
 
 SocketSetNoDelayFunction::SocketSetNoDelayFunction()
     : params_(NULL) {
 }
 
 SocketSetNoDelayFunction::~SocketSetNoDelayFunction() {}
 
 bool SocketSetNoDelayFunction::Prepare() {
   params_ = api::experimental_socket::SetNoDelay::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetNoDelayFunction::Work() {
   bool result = false;
   Socket* socket = controller()->GetSocket(params_->socket_id);
   if (socket)
     result = socket->SetNoDelay(params_->no_delay);
   else
     error_ = kSocketNotFoundError;
-  result_.reset(Value::CreateBooleanValue(result));
+  SetSingleResult(Value::CreateBooleanValue(result));
 }
 
 }  // namespace extensions