Added support for multiple parameters to Extension API callbacks.

chrome/browser/chromeos/extensions/file_browser_private_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/chromeos/extensions/file_browser_private_api.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 467 matching lines @@
 }
 
 void RequestLocalFileSystemFunction::RespondSuccessOnUIThread(
     const std::string& name, const GURL& root_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Add gdata mount point immediately when we kick of first instance of file
   // manager. The actual mount event will be sent to UI only when we perform
   // proper authentication.
   if (gdata::util::IsGDataAvailable(profile_))
     AddGDataMountPoint(profile_, extension_id(), render_view_host());
-  result_.reset(new DictionaryValue());
+  SetSingleResult(new DictionaryValue());
   DictionaryValue* dict = reinterpret_cast<DictionaryValue*>(result_.get());
   dict->SetString("name", name);
   dict->SetString("path", root_path.spec());
   dict->SetInteger("error", base::PLATFORM_FILE_OK);
   SendResponse(true);
 }
 
 void RequestLocalFileSystemFunction::RespondFailedOnUIThread(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 19 matching lines @@
           *virtual_path,
           false);
   if (root_path == FilePath())
     return false;
 
   *local_path = root_path.Append(*virtual_path);
   return true;
 }
 
 void FileWatchBrowserFunctionBase::RespondOnUIThread(bool success) {
-  result_.reset(Value::CreateBooleanValue(success));
+  SetSingleResult(Value::CreateBooleanValue(success));
   SendResponse(success);
 }
 
 bool FileWatchBrowserFunctionBase::RunImpl() {
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
   std::string url;
   if (!args_->GetString(0, &url) || url.empty())
@@ skipping 115 matching lines @@
 
   std::vector<GURL> file_urls;
   for (size_t i = 0; i < files_list->GetSize(); ++i) {
     std::string file_url;
     if (!files_list->GetString(i, &file_url))
       return false;
     file_urls.push_back(GURL(file_url));
   }
 
   ListValue* result_list = new ListValue();
-  result_.reset(result_list);
+  SetSingleResult(result_list);
 
   file_handler_util::LastUsedHandlerList common_tasks;
   if (!file_handler_util::FindCommonTasks(profile_, file_urls, &common_tasks))
     return false;
 
   ExtensionService* service = profile_->GetExtensionService();
   for (file_handler_util::LastUsedHandlerList::const_iterator iter =
            common_tasks.begin();
        iter != common_tasks.end();
        ++iter) {
@@ skipping 79 matching lines @@
       FileTaskExecutor::Create(profile(),
                                source_url(),
                                extension_id,
                                action_id));
 
   if (!executor->ExecuteAndNotify(
       file_urls,
       base::Bind(&ExecuteTasksFileBrowserFunction::OnTaskExecuted, this)))
     return false;
 
-  result_.reset(new base::FundamentalValue(true));
+  SetSingleResult(new base::FundamentalValue(true));
   return true;
 }
 
 SetDefaultTaskFileBrowserFunction::SetDefaultTaskFileBrowserFunction() {}
 
 SetDefaultTaskFileBrowserFunction::~SetDefaultTaskFileBrowserFunction() {}
 
 bool SetDefaultTaskFileBrowserFunction::RunImpl() {
   // First param is task id that was to the extension with setDefaultTask call.
   std::string task_id;
   if (!args_->GetString(0, &task_id) || !task_id.size())
     return false;
 
   BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &file_handler_util::UpdateFileHandlerUsageStats,
             profile_, task_id));
 
-  result_.reset(new base::FundamentalValue(true));
+  SetSingleResult(new base::FundamentalValue(true));
   return true;
 }
 
 FileBrowserFunction::FileBrowserFunction() {
 }
 
 FileBrowserFunction::~FileBrowserFunction() {
 }
 
 int32 FileBrowserFunction::GetTabId() const {
@@ skipping 193 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   bool success = true;
   for (SelectedFileInfoList::const_iterator iter = files.begin();
        iter != files.end();
        ++iter) {
     bool handled = file_manager_util::ExecuteBuiltinHandler(
         GetCurrentBrowser(), iter->path, internal_task_id);
     if (!handled && files.size() == 1)
       success = false;
   }
-  result_.reset(Value::CreateBooleanValue(success));
+  SetSingleResult(Value::CreateBooleanValue(success));
   SendResponse(true);
 }
 
 SelectFilesFunction::SelectFilesFunction() {
 }
 
 SelectFilesFunction::~SelectFilesFunction() {
 }
 
 bool SelectFilesFunction::RunImpl() {
@@ skipping 52 matching lines @@
   if (!args_->GetString(0, &file_url)) {
     return false;
   }
 
   std::string mount_type_str;
   if (!args_->GetString(1, &mount_type_str)) {
     return false;
   }
 
   // Set default return source path to the empty string.
-  result_.reset(Value::CreateStringValue(""));
+  SetSingleResult(Value::CreateStringValue(""));
 
   chromeos::MountType mount_type =
       DiskMountManager::MountTypeFromString(mount_type_str);
   switch (mount_type) {
     case chromeos::MOUNT_TYPE_INVALID: {
       error_ = "Invalid mount type";
       SendResponse(false);
       break;
     }
     case chromeos::MOUNT_TYPE_GDATA: {
@@ skipping 25 matching lines @@
 void AddMountFunction::RaiseGDataMountEvent(gdata::GDataErrorCode error) {
   chromeos::MountError error_code = chromeos::MOUNT_ERROR_NONE;
   // For the file manager to work offline, GDATA_NO_CONNECTION is allowed.
   if (error == gdata::HTTP_SUCCESS || error == gdata::GDATA_NO_CONNECTION) {
     error_code = chromeos::MOUNT_ERROR_NONE;
   } else {
     error_code = chromeos::MOUNT_ERROR_NOT_AUTHENTICATED;
   }
   // Pass back the gdata mount point path as source path.
   const std::string& gdata_path = gdata::util::GetGDataMountPointPathAsString();
-  result_.reset(Value::CreateStringValue(gdata_path));
+  SetSingleResult(Value::CreateStringValue(gdata_path));
   DiskMountManager::MountPointInfo mount_info(
       gdata_path,
       gdata_path,
       chromeos::MOUNT_TYPE_GDATA,
       chromeos::disks::MOUNT_CONDITION_NONE);
   // Raise mount event
   FileBrowserEventRouterFactory::GetForProfile(profile_)->
       MountCompleted(DiskMountManager::MOUNTING, error_code, mount_info);
 }
 
@@ skipping 31 matching lines @@
   }
 }
 
 void AddMountFunction::OnMountedStateSet(const std::string& mount_type,
                                          const FilePath::StringType& file_name,
                                          base::PlatformFileError error,
                                          const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   // Pass back the actual source path of the mount point.
-  result_.reset(Value::CreateStringValue(file_path.value()));
+  SetSingleResult(Value::CreateStringValue(file_path.value()));
   SendResponse(true);
   // MountPath() takes a std::string.
   disk_mount_manager->MountPath(file_path.AsUTF8Unsafe(),
                                 FilePath(file_name).Extension(), file_name,
                                 DiskMountManager::MountTypeFromString(
                                     mount_type));
 }
 
 RemoveMountFunction::RemoveMountFunction() {
 }
@@ skipping 35 matching lines @@
 }
 
 GetMountPointsFunction::~GetMountPointsFunction() {
 }
 
 bool GetMountPointsFunction::RunImpl() {
   if (args_->GetSize())
     return false;
 
   base::ListValue *mounts = new base::ListValue();
-  result_.reset(mounts);
+  SetSingleResult(mounts);
 
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   DiskMountManager::MountPointMap mount_points =
       disk_mount_manager->mount_points();
 
   for (DiskMountManager::MountPointMap::const_iterator it =
            mount_points.begin();
        it != mount_points.end();
        ++it) {
     mounts->Append(CreateValueFromMountPoint(profile_, it->second,
@@ skipping 90 matching lines @@
           this,
           total_size_kb, remaining_size_kb));
 }
 
 void GetSizeStatsFunction::GetSizeStatsCallbackOnUIThread(
     size_t total_size_kb,
     size_t remaining_size_kb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::DictionaryValue* sizes = new base::DictionaryValue();
-  result_.reset(sizes);
+  SetSingleResult(sizes);
 
   sizes->SetInteger("totalSizeKB", total_size_kb);
   sizes->SetInteger("remainingSizeKB", remaining_size_kb);
 
   SendResponse(true);
 }
 
 FormatDeviceFunction::FormatDeviceFunction() {
 }
 
@@ skipping 65 matching lines @@
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Should contain volume's mount path.
   if (files.size() != 1) {
     error_ = "Invalid mount path.";
     SendResponse(false);
     return;
   }
 
-  result_.reset();
+  SetSingleResult();
 
   const DiskMountManager::Disk* volume = GetVolumeAsDisk(
       files[0].path.value());
   if (volume) {
     DictionaryValue* volume_info =
         CreateValueFromDisk(profile_, volume);
-    result_.reset(volume_info);
+    SetSingleResult(volume_info);
   }
 
   SendResponse(true);
 }
 
 bool ToggleFullscreenFunction::RunImpl() {
   Browser* browser = GetCurrentBrowser();
   if (browser) {
     browser->ToggleFullscreenModeWithExtension(
         file_manager_util::GetFileBrowserExtensionUrl());
   }
   return true;
 }
 
 bool IsFullscreenFunction::RunImpl() {
   Browser* browser = GetCurrentBrowser();
-  result_.reset(Value::CreateBooleanValue(
+  SetSingleResult(Value::CreateBooleanValue(
       browser && browser->window() && browser->window()->IsFullscreen()));
   return true;
 }
 
 bool FileDialogStringsFunction::RunImpl() {
-  result_.reset(new DictionaryValue());
+  SetSingleResult(new DictionaryValue());
   DictionaryValue* dict = reinterpret_cast<DictionaryValue*>(result_.get());
 
 #define SET_STRING(ns, id) \
   dict->SetString(#id, l10n_util::GetStringUTF16(ns##_##id))
 
   SET_STRING(IDS, WEB_FONT_FAMILY);
   SET_STRING(IDS, WEB_FONT_SIZE);
 
   SET_STRING(IDS_FILE_BROWSER, ROOT_DIRECTORY_LABEL);
   SET_STRING(IDS_FILE_BROWSER, ARCHIVE_DIRECTORY_LABEL);
@@ skipping 282 matching lines @@
 
   file_properties_.reset(new base::ListValue);
 
   current_index_ = 0;
   GetNextFileProperties();
 }
 
 void GetGDataFilePropertiesFunction::GetNextFileProperties() {
   if (current_index_ >= path_list_->GetSize()) {
     // Exit of asynchronous look and return the result.
-    result_.reset(file_properties_.release());
+    SetSingleResult(file_properties_.release());
     SendResponse(true);
     return;
   }
 
   std::string file_str;
   path_list_->GetString(current_index_, &file_str);
   GURL file_url = GURL(file_str);
   FilePath file_path = GetVirtualPathFromURL(file_url);
 
   base::DictionaryValue* property_dict = new base::DictionaryValue;
@@ skipping 201 matching lines @@
 
   ListValue* locations = new ListValue;
   for (size_t i = 0; i < files.size(); ++i) {
     if (gdata::util::IsUnderGDataMountPoint(files[i].path)) {
       locations->Append(Value::CreateStringValue("drive"));
     } else {
       locations->Append(Value::CreateStringValue("local"));
     }
   }
 
-  result_.reset(locations);
+  SetSingleResult(locations);
   SendResponse(true);
 }
 
 GetGDataFilesFunction::GetGDataFilesFunction()
     : local_paths_(NULL) {
 }
 
 GetGDataFilesFunction::~GetGDataFilesFunction() {
 }
 
@@ skipping 28 matching lines @@
     remaining_gdata_paths_.push(gdata_path);
   }
 
   local_paths_ = new ListValue;
   GetFileOrSendResponse();
 }
 
 void GetGDataFilesFunction::GetFileOrSendResponse() {
   // Send the response if all files are obtained.
   if (remaining_gdata_paths_.empty()) {
-    result_.reset(local_paths_);
+    SetSingleResult(local_paths_);
     SendResponse(true);
     return;
   }
 
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   DCHECK(system_service);
 
   // Get the file on the top of the queue.
   FilePath gdata_path = remaining_gdata_paths_.front();
@@ skipping 49 matching lines @@
       profile_, source_url_.GetOrigin(), list);
 }
 
 bool GetFileTransfersFunction::RunImpl() {
   scoped_ptr<ListValue> progress_status_list(GetFileTransfersList());
   if (!progress_status_list.get()) {
     SendResponse(false);
     return false;
   }
 
-  result_.reset(progress_status_list.release());
+  SetSingleResult(progress_status_list.release());
   SendResponse(true);
   return true;
 }
 
 
 CancelFileTransfersFunction::CancelFileTransfersFunction() {}
 
 CancelFileTransfersFunction::~CancelFileTransfersFunction() {}
 
 bool CancelFileTransfersFunction::RunImpl() {
@@ skipping 43 matching lines @@
     GURL file_url;
     if (file_manager_util::ConvertFileToFileSystemUrl(profile_,
             gdata::util::GetSpecialRemoteRootPath().Append(file_path),
             source_url_.GetOrigin(),
             &file_url)) {
       result->SetString("fileUrl", file_url.spec());
     }
 
     responses->Append(result.release());
   }
-  result_.reset(responses.release());
+  SetSingleResult(responses.release());
   SendResponse(true);
 }
 
 TransferFileFunction::TransferFileFunction() {}
 
 TransferFileFunction::~TransferFileFunction() {}
 
 bool TransferFileFunction::RunImpl() {
   std::string local_file_url;
   std::string remote_file_url;
@@ skipping 80 matching lines @@
     AddGDataMountPoint(profile_, extension_id(), render_view_host());
 
   value->SetBoolean("driveEnabled", driveEnabled);
 
   value->SetBoolean("cellularDisabled",
                     service->GetBoolean(prefs::kDisableGDataOverCellular));
 
   value->SetBoolean("hostedFilesDisabled",
                     service->GetBoolean(prefs::kDisableGDataHostedFiles));
 
-  result_.reset(value.release());
+  SetSingleResult(value.release());
   return true;
 }
 
 // Write GData-related preferences.
 bool SetGDataPreferencesFunction::RunImpl() {
   base::DictionaryValue* value = NULL;
 
   if (!args_->GetDictionary(0, &value) || !value)
     return false;
 
@@ skipping 31 matching lines @@
 
 void GetPathForDriveSearchResultFunction::OnEntryFound(
     base::PlatformFileError error,
     const FilePath& entry_path,
     scoped_ptr<gdata::GDataEntryProto> entry_proto) {
   if (error != base::PLATFORM_FILE_OK) {
     SendResponse(false);
     return;
   }
 
-  result_.reset(Value::CreateStringValue(entry_path.value()));
+  SetSingleResult(Value::CreateStringValue(entry_path.value()));
   SendResponse(true);
 }
 
 bool SearchDriveFunction::RunImpl() {
   if (!args_->GetString(0, &query_))
     return false;
 
   BrowserContext::GetFileSystemContext(profile())->OpenFileSystem(
       source_url_.GetOrigin(), fileapi::kFileSystemTypeExternal, false,
       base::Bind(&SearchDriveFunction::OnFileSystemOpened, this));
@@ skipping 39 matching lines @@
   for (size_t i = 0; i < results->size(); ++i) {
     DictionaryValue* entry = new DictionaryValue();
     entry->SetString("fileSystemName", file_system_name_);
     entry->SetString("fileSystemRoot", file_system_url_.spec());
     entry->SetString("fileFullPath", "/" + results->at(i).path.value());
     entry->SetBoolean("fileIsDirectory", results->at(i).is_directory);
 
     entries->Append(entry);
   }
 
-  result_.reset(entries);
+  SetSingleResult(entries);
   SendResponse(true);
 }
 
 bool GetNetworkConnectionStateFunction::RunImpl() {
   chromeos::NetworkLibrary* network_library =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   if (!network_library)
     return false;
 
   const chromeos::Network* active_network = network_library->active_network();
 
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
   value->SetBoolean("online", active_network && active_network->online());
 
   std::string type_string;
   if (!active_network)
     type_string = "none";
   else if (active_network->type() == chromeos::TYPE_CELLULAR)
     type_string = "cellular";
   else
     type_string = "ethernet";  // Currently we do not care about other types.
 
   value->SetString("type", type_string);
-  result_.reset(value.release());
+  SetSingleResult(value.release());
 
   return true;
 }
 
 bool RequestDirectoryRefreshFunction::RunImpl() {
   std::string file_url_as_string;
   if (!args_->GetString(0, &file_url_as_string))
     return false;
 
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }