Added support for multiple parameters to Extension API callbacks.

chrome/browser/extensions/api/serial/serial_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/serial/serial_api.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/api/api_resource_controller.h"
 #include "chrome/browser/extensions/api/serial/serial_connection.h"
 #include "chrome/browser/extensions/api/serial/serial_port_enumerator.h"
@@ skipping 30 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   ListValue* ports = new ListValue();
   SerialPortEnumerator::StringSet port_names =
       SerialPortEnumerator::GenerateValidSerialPortNames();
   SerialPortEnumerator::StringSet::const_iterator i = port_names.begin();
   while (i != port_names.end()) {
     ports->Append(Value::CreateStringValue(*i++));
   }
 
-  result_.reset(ports);
+  SetResult(ports);
 }
 
 bool SerialGetPortsFunction::Respond() {
   return true;
 }
 
 // It's a fool's errand to come up with a default bitrate, because we don't get
 // to control both sides of the communication. Unless the other side has
 // implemented auto-bitrate detection (rare), if we pick the wrong rate, then
 // you're gonna have a bad time. Close doesn't count.
@@ skipping 46 matching lines @@
 
     bool open_result = serial_connection->Open();
     if (!open_result) {
       serial_connection->Close();
       controller()->RemoveSerialConnection(id);
       id = -1;
     }
 
     DictionaryValue* result = new DictionaryValue();
     result->SetInteger(kConnectionIdKey, id);
-    result_.reset(result);
+    SetResult(result);
     AsyncWorkCompleted();
   } else {
     DictionaryValue* result = new DictionaryValue();
     result->SetInteger(kConnectionIdKey, -1);
-    result_.reset(result);
+    SetResult(result);
     AsyncWorkCompleted();
   }
 }
 
 SerialConnection* SerialOpenFunction::CreateSerialConnection(
     const std::string& port,
     int bitrate,
     APIResourceEventNotifier* event_notifier) {
   return new SerialConnection(port, bitrate, event_notifier);
 }
@@ skipping 25 matching lines @@
 void SerialCloseFunction::Work() {
   bool close_result = false;
   SerialConnection* serial_connection =
       controller()->GetSerialConnection(params_->connection_id);
   if (serial_connection) {
     serial_connection->Close();
     controller()->RemoveSerialConnection(params_->connection_id);
     close_result = true;
   }
 
-  result_.reset(Value::CreateBooleanValue(close_result));
+  SetResult(Value::CreateBooleanValue(close_result));
 }
 
 bool SerialCloseFunction::Respond() {
   return true;
 }
 
 SerialReadFunction::SerialReadFunction() {
 }
 
 SerialReadFunction::~SerialReadFunction() {
@@ skipping 17 matching lines @@
 
   DictionaryValue* result = new DictionaryValue();
 
   // The API is defined to require a 'data' value, so we will always
   // create a BinaryValue, even if it's zero-length.
   if (bytes_read < 0)
     bytes_read = 0;
   result->SetInteger(kBytesReadKey, bytes_read);
   result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(
       reinterpret_cast<char*>(&byte), bytes_read));
-  result_.reset(result);
+  SetResult(result);
 }
 
 bool SerialReadFunction::Respond() {
   return true;
 }
 
 SerialWriteFunction::SerialWriteFunction()
     : io_buffer_(NULL), io_buffer_size_(0) {
 }
 
@@ skipping 16 matching lines @@
   int bytes_written = -1;
   SerialConnection* serial_connection =
       controller()->GetSerialConnection(params_->connection_id);
   if (serial_connection)
     bytes_written = serial_connection->Write(io_buffer_, io_buffer_size_);
   else
     error_ = kSerialConnectionNotFoundError;
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
-  result_.reset(result);
+  SetResult(result);
 }
 
 bool SerialWriteFunction::Respond() {
   return true;
 }
 
 SerialFlushFunction::SerialFlushFunction() {
 }
 
 SerialFlushFunction::~SerialFlushFunction() {
 }
 
 bool SerialFlushFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::experimental_serial::Flush::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SerialFlushFunction::Work() {
   bool flush_result = false;
   SerialConnection* serial_connection =
       controller()->GetSerialConnection(params_->connection_id);
   if (serial_connection) {
     serial_connection->Flush();
     flush_result = true;
   }
 
-  result_.reset(Value::CreateBooleanValue(flush_result));
+  SetResult(Value::CreateBooleanValue(flush_result));
 }
 
 bool SerialFlushFunction::Respond() {
   return true;
 }
 
 SerialGetControlSignalsFunction::SerialGetControlSignalsFunction()
     : api_response_(false) {
 }
 
@@ skipping 20 matching lines @@
       result->SetBoolean(kDcdKey, control_signals.dcd);
       result->SetBoolean(kCtsKey, control_signals.cts);
     } else {
       error_ = kErrorGetControlSignalsFailed;
     }
   } else {
     error_ = kSerialConnectionNotFoundError;
     result->SetBoolean(kSuccessKey, false);
   }
 
-  result_.reset(result);
+  SetResult(result);
 }
 
 bool SerialGetControlSignalsFunction::Respond() {
   return api_response_;
 }
 
 SerialSetControlSignalsFunction::SerialSetControlSignalsFunction() {
 }
 
 SerialSetControlSignalsFunction::~SerialSetControlSignalsFunction() {
@@ skipping 13 matching lines @@
       controller()->GetSerialConnection(params_->connection_id);
   if (serial_connection) {
     SerialConnection::ControlSignals control_signals = { 0 };
     control_signals.should_set_dtr = params_->options.dtr.get() != NULL;
     if (control_signals.should_set_dtr)
       control_signals.dtr = *(params_->options.dtr);
     control_signals.should_set_rts = params_->options.rts.get() != NULL;
     if (control_signals.should_set_rts)
       control_signals.rts = *(params_->options.rts);
     if (serial_connection->SetControlSignals(control_signals)) {
-      result_.reset(Value::CreateBooleanValue(true));
+      SetResult(Value::CreateBooleanValue(true));
     } else {
       error_ = kErrorSetControlSignalsFailed;
-      result_.reset(Value::CreateBooleanValue(false));
+      SetResult(Value::CreateBooleanValue(false));
     }
   } else {
     error_ = kSerialConnectionNotFoundError;
-    result_.reset(Value::CreateBooleanValue(false));
+    SetResult(Value::CreateBooleanValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions