Added support for multiple parameters to Extension API callbacks.

chrome/browser/extensions/api/permissions/permissions_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/permissions/permissions_api.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/permissions/permissions_api_helpers.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/permissions_updater.h"
@@ skipping 41 matching lines @@
 }  // namespace
 
 bool ContainsPermissionsFunction::RunImpl() {
   scoped_ptr<Contains::Params> params(Contains::Params::Create(*args_));
 
   scoped_refptr<PermissionSet> permissions =
       helpers::UnpackPermissionSet(params->permissions, &error_);
   if (!permissions.get())
     return false;
 
-  result_.reset(Contains::Result::Create(
+  SetSingleResult(Contains::Result::Create(
       GetExtension()->GetActivePermissions()->Contains(*permissions)));
   return true;
 }
 
 bool GetAllPermissionsFunction::RunImpl() {
   scoped_ptr<Permissions> permissions =
       helpers::PackPermissionSet(GetExtension()->GetActivePermissions());
-  result_.reset(GetAll::Result::Create(*permissions));
+  SetSingleResult(GetAll::Result::Create(*permissions));
   return true;
 }
 
 bool RemovePermissionsFunction::RunImpl() {
   scoped_ptr<Remove::Params> params(Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<PermissionSet> permissions =
       helpers::UnpackPermissionSet(params->permissions, &error_);
   if (!permissions.get())
@@ skipping 13 matching lines @@
       return false;
     }
   }
 
   // Make sure we don't remove any required pemissions.
   const PermissionSet* required = extension->required_permission_set();
   scoped_refptr<PermissionSet> intersection(
       PermissionSet::CreateIntersection(permissions.get(), required));
   if (!intersection->IsEmpty()) {
     error_ = kCantRemoveRequiredPermissionsError;
-    result_.reset(Remove::Result::Create(false));
+    SetSingleResult(Remove::Result::Create(false));
     return false;
   }
 
   PermissionsUpdater(profile()).RemovePermissions(extension, permissions.get());
-  result_.reset(Remove::Result::Create(true));
+  SetSingleResult(Remove::Result::Create(true));
   return true;
 }
 
 // static
 void RequestPermissionsFunction::SetAutoConfirmForTests(bool should_proceed) {
   auto_confirm_for_tests = should_proceed ? PROCEED : ABORT;
 }
 
 // static
 void RequestPermissionsFunction::SetIgnoreUserGestureForTests(
     bool ignore) {
   ignore_user_gesture_for_tests = ignore;
 }
 
 RequestPermissionsFunction::RequestPermissionsFunction() {}
 
 void RequestPermissionsFunction::InstallUIProceed() {
   PermissionsUpdater perms_updater(profile());
   perms_updater.AddPermissions(GetExtension(), requested_permissions_.get());
 
-  result_.reset(Request::Result::Create(true));
+  SetSingleResult(Request::Result::Create(true));
   SendResponse(true);
 
   Release();  // Balanced in RunImpl().
 }
 
 void RequestPermissionsFunction::InstallUIAbort(bool user_initiated) {
-  result_.reset(Request::Result::Create(false));
+  SetSingleResult(Request::Result::Create(false));
   SendResponse(true);
 
   Release();  // Balanced in RunImpl().
 }
 
 RequestPermissionsFunction::~RequestPermissionsFunction() {}
 
 bool RequestPermissionsFunction::RunImpl() {
   if (!user_gesture() && !ignore_user_gesture_for_tests) {
     error_ = kUserGestureRequiredError;
@@ skipping 20 matching lines @@
       error_ = ExtensionErrorUtils::FormatErrorMessage(
           kNotWhitelistedError, api->name());
       return false;
     }
   }
 
   // The requested permissions must be defined as optional in the manifest.
   if (!GetExtension()->optional_permission_set()->Contains(
           *requested_permissions_)) {
     error_ = kNotInOptionalPermissionsError;
-    result_.reset(Request::Result::Create(false));
+    SetSingleResult(Request::Result::Create(false));
     return false;
   }
 
   // We don't need to prompt the user if the requested permissions are a subset
   // of the granted permissions set.
   scoped_refptr<const PermissionSet> granted =
       prefs->GetGrantedPermissions(GetExtension()->id());
   if (granted.get() && granted->Contains(*requested_permissions_)) {
     PermissionsUpdater perms_updater(profile());
     perms_updater.AddPermissions(GetExtension(), requested_permissions_.get());
-    result_.reset(Request::Result::Create(true));
+    SetSingleResult(Request::Result::Create(true));
     SendResponse(true);
     return true;
   }
 
   // Filter out the granted permissions so we only prompt for new ones.
   requested_permissions_ = PermissionSet::CreateDifference(
       requested_permissions_.get(), granted.get());
 
   AddRef();  // Balanced in InstallUIProceed() / InstallUIAbort().
 
   // We don't need to show the prompt if there are no new warnings, or if
   // we're skipping the confirmation UI. All extension types but INTERNAL
   // are allowed to silently increase their permission level.
   if (auto_confirm_for_tests == PROCEED ||
       requested_permissions_->GetWarningMessages().size() == 0) {
     InstallUIProceed();
   } else if (auto_confirm_for_tests == ABORT) {
     // Pretend the user clicked cancel.
     InstallUIAbort(true);
   } else {
     CHECK_EQ(DO_NOT_SKIP, auto_confirm_for_tests);
     install_ui_.reset(
         chrome::CreateExtensionInstallPromptWithBrowser(GetCurrentBrowser()));
     install_ui_->ConfirmPermissions(
         this, GetExtension(), requested_permissions_.get());
   }
 
   return true;
 }