Added support for multiple parameters to Extension API callbacks.

chrome/browser/extensions/api/bluetooth/bluetooth_apitest_chromeos.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 <string.h>
 
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_device.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
@@ skipping 28 matching lines @@
         true /* paired */, false /* bonded */, true /* connected */));
     device2_.reset(new testing::NiceMock<chromeos::MockBluetoothDevice>(
         mock_adapter_, "d2", "21:22:23:24:25:26",
         false /* paired */, true /* bonded */, false /* connected */));
   }
 
   void expectBooleanResult(bool expected,
                            UIThreadExtensionFunction* function,
                            const std::string& args) {
     scoped_ptr<base::Value> result(
-        utils::RunFunctionAndReturnResult(function, args, browser()));
+        utils::RunFunctionAndReturnSingleResult(function, args, browser()));
     ASSERT_TRUE(result.get() != NULL);
     ASSERT_EQ(base::Value::TYPE_BOOLEAN, result->GetType());
     bool boolean_value;
     result->GetAsBoolean(&boolean_value);
     EXPECT_EQ(expected, boolean_value);
   }
 
   template <class T>
   T* setupFunction(T* function) {
     function->set_extension(empty_extension_.get());
@@ skipping 84 matching lines @@
       .WillOnce(testing::Return(false));
   EXPECT_CALL(*device2_, ProvidesServiceWithUUID("foo"))
       .WillOnce(testing::Return(true));
 
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .WillOnce(testing::Return(devices));
 
   scoped_refptr<api::BluetoothGetDevicesFunction> get_devices;
 
   get_devices = setupFunction(new api::BluetoothGetDevicesFunction);
-  scoped_ptr<base::Value> result(utils::RunFunctionAndReturnResult(
+  scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
         get_devices,
         "[{\"uuid\":\"foo\"}]",
         browser()));
 
   ASSERT_EQ(base::Value::TYPE_LIST, result->GetType());
   base::ListValue* list;
   ASSERT_TRUE(result->GetAsList(&list));
 
   EXPECT_EQ(1u, list->GetSize());
   base::Value* device_value;
@@ skipping 18 matching lines @@
   ASSERT_TRUE(device->GetBoolean("connected", &connected));
   EXPECT_FALSE(connected);
 
   // Try again with no options
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .WillOnce(testing::Return(devices));
 
   get_devices = setupFunction(new api::BluetoothGetDevicesFunction);
   result.reset(
-      utils::RunFunctionAndReturnResult(get_devices, "[{}]", browser()));
+      utils::RunFunctionAndReturnSingleResult(get_devices, "[{}]", browser()));
 
   ASSERT_EQ(base::Value::TYPE_LIST, result->GetType());
   ASSERT_TRUE(result->GetAsList(&list));
 
   EXPECT_EQ(2u, list->GetSize());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetLocalOutOfBandPairingData) {
   EXPECT_CALL(*mock_adapter_,
               ReadLocalOutOfBandPairingData(
                   testing::Truly(CallOutOfBandPairingDataCallback),
                   testing::_));
 
   scoped_refptr<api::BluetoothGetLocalOutOfBandPairingDataFunction>
       get_oob_function(setupFunction(
             new api::BluetoothGetLocalOutOfBandPairingDataFunction));
 
-  scoped_ptr<base::Value> result(
-      utils::RunFunctionAndReturnResult(get_oob_function, "[]", browser()));
+  scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
+      get_oob_function, "[]", browser()));
 
   base::DictionaryValue* dict;
   EXPECT_TRUE(result->GetAsDictionary(&dict));
 
   base::BinaryValue* binary_value;
   EXPECT_TRUE(dict->GetBinary("hash", &binary_value));
   EXPECT_STREQ(kOutOfBandPairingDataHash,
       std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
   EXPECT_TRUE(dict->GetBinary("randomizer", &binary_value));
   EXPECT_STREQ(kOutOfBandPairingDataRandomizer,
@@ skipping 24 matching lines @@
 
   char buf[64];
   snprintf(buf, sizeof(buf),
            "[{\"deviceAddress\":\"%s\"}]", device_address.c_str());
   std::string params(buf);
 
   scoped_refptr<api::BluetoothSetOutOfBandPairingDataFunction> set_oob_function;
   set_oob_function = setupFunction(
       new api::BluetoothSetOutOfBandPairingDataFunction);
   // There isn't actually a result.
-  (void)utils::RunFunctionAndReturnResult(set_oob_function, params, browser());
+  (void)utils::RunFunctionAndReturnSingleResult(
+      set_oob_function, params, browser());
 
   // Try again with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   testing::Mock::VerifyAndClearExpectations(device1_.get());
   EXPECT_CALL(*mock_adapter_, GetDevice(device_address))
       .WillOnce(testing::Return(device1_.get()));
   EXPECT_CALL(*device1_,
               ClearOutOfBandPairingData(testing::_,
                                         testing::Truly(CallClosure)));
 
@@ skipping 31 matching lines @@
   (void)utils::RunFunctionAndReturnError(start_function, "[]", browser());
 
   // Reset to try stopping
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(false,
                              testing::Truly(CallClosure),
                              testing::_));
   scoped_refptr<api::BluetoothStopDiscoveryFunction> stop_function;
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
-  (void)utils::RunFunctionAndReturnResult(stop_function, "[]", browser());
+  (void)utils::RunFunctionAndReturnSingleResult(stop_function, "[]", browser());
 
   // Reset to try stopping with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(false,
                              testing::_,
                              testing::Truly(CallClosure)));
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
   error = utils::RunFunctionAndReturnError(stop_function, "[]", browser());
   ASSERT_TRUE(!error.empty());
@@ skipping 41 matching lines @@
 
   event_router()->AdapterPoweredChanged(mock_adapter_, true);
   event_router()->AdapterPoweredChanged(mock_adapter_, false);
   event_router()->AdapterPresentChanged(mock_adapter_, true);
   event_router()->AdapterPresentChanged(mock_adapter_, false);
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }