Support requesting subsets of host permissions using the permissions API.

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_prefs.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 50 matching lines @@
 
   ExtensionPrefs* prefs = ExtensionSystem::Get(profile_)->extension_prefs();
   scoped_refptr<PermissionSet> permissions =
       helpers::UnpackPermissionSet(params->permissions,
                                    prefs->AllowFileAccess(extension_->id()),
                                    &error_);
   if (!permissions.get())
     return false;
 
   results_ = Contains::Results::Create(
-      GetExtension()->GetActivePermissions()->Contains(*permissions));
+      GetExtension()->GetActivePermissions()->ContainsOrEncompasses(
+          *permissions));
   return true;
 }
 
 bool PermissionsGetAllFunction::RunImpl() {
   scoped_ptr<Permissions> permissions =
       helpers::PackPermissionSet(GetExtension()->GetActivePermissions());
   results_ = GetAll::Results::Create(*permissions);
   return true;
 }
 
@@ skipping 21 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;
-    results_ = Remove::Results::Create(false);
     return false;
   }
 
   PermissionsUpdater(profile()).RemovePermissions(extension, permissions.get());
   results_ = Remove::Results::Create(true);
   return true;
 }
 
 // static
 void PermissionsRequestFunction::SetAutoConfirmForTests(bool should_proceed) {
@@ skipping 28 matching lines @@
 
 bool PermissionsRequestFunction::RunImpl() {
   results_ = Request::Results::Create(false);
 
   if (!user_gesture() && !ignore_user_gesture_for_tests) {
     error_ = kUserGestureRequiredError;
     return false;
   }
 
   scoped_ptr<Request::Params> params(Request::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
+  EXTENSION_FUNCTION_VALIDATE(params);
 
   ExtensionPrefs* prefs = ExtensionSystem::Get(profile_)->extension_prefs();
 
   requested_permissions_ =
       helpers::UnpackPermissionSet(params->permissions,
                                    prefs->AllowFileAccess(extension_->id()),
                                    &error_);
   if (!requested_permissions_.get())
     return false;
 
   // Make sure they're only requesting permissions supported by this API.
   APIPermissionSet apis = requested_permissions_->apis();
   for (APIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     if (!i->info()->supports_optional()) {
       error_ = ErrorUtils::FormatErrorMessage(
           kNotWhitelistedError, i->name());
       return false;
     }
   }
 
   // Filter out permissions that do not need to be listed in the optional
   // section of the manifest.
   scoped_refptr<extensions::PermissionSet>
       manifest_required_requested_permissions =
           PermissionSet::ExcludeNotInManifestPermissions(
               requested_permissions_.get());
 
   // The requested permissions must be defined as optional in the manifest.
-  if (!GetExtension()->optional_permission_set()->Contains(
+  if (!GetExtension()->optional_permission_set()->ContainsOrEncompasses(
           *manifest_required_requested_permissions)) {
     error_ = kNotInOptionalPermissionsError;
-    results_ = Request::Results::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_)) {
+  if (granted && granted->ContainsOrEncompasses(*requested_permissions_)) {
     PermissionsUpdater perms_updater(profile());
     perms_updater.AddPermissions(GetExtension(), requested_permissions_.get());
     results_ = Request::Results::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());
@@ skipping 12 matching lines @@
     InstallUIAbort(true);
   } else {
     CHECK_EQ(DO_NOT_SKIP, auto_confirm_for_tests);
     install_ui_.reset(new ExtensionInstallPrompt(GetAssociatedWebContents()));
     install_ui_->ConfirmPermissions(
         this, GetExtension(), requested_permissions_.get());
   }
 
   return true;
 }