Cleanup extension permissions module.

chrome/browser/extensions/extension_permissions_api.cc

 // Copyright (c) 2011 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/extension_permissions_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_messages.h"
-#include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/extensions/url_pattern_set.h"
+#include "content/browser/renderer_host/render_process_host.h"
 #include "content/public/browser/notification_service.h"
 #include "googleurl/src/gurl.h"
 
 namespace {
 
 const char kApisKey[] = "permissions";
 const char kOriginsKey[] = "origins";
 
 const char kCantRemoveRequiredPermissionsError[] =
     "You cannot remove required permissions.";
@@ skipping 99 matching lines @@
       origins.AddPattern(origin);
     }
   }
 
   *ptr = new ExtensionPermissionSet(apis, origins, URLPatternSet());
   return true;
 }
 
 } // namespace
 
-ExtensionPermissionsManager::ExtensionPermissionsManager(
+ExtensionPermissionsUpdater::ExtensionPermissionsUpdater(
     ExtensionService* extension_service)
     : extension_service_(extension_service) {}
 
-ExtensionPermissionsManager::~ExtensionPermissionsManager() {}
+ExtensionPermissionsUpdater::~ExtensionPermissionsUpdater() {}
 
-void ExtensionPermissionsManager::AddPermissions(
+void ExtensionPermissionsUpdater::AddPermissions(
     const Extension* extension, const ExtensionPermissionSet* permissions) {
   scoped_refptr<const ExtensionPermissionSet> existing(
       extension->GetActivePermissions());
   scoped_refptr<ExtensionPermissionSet> total(
       ExtensionPermissionSet::CreateUnion(existing, permissions));
   scoped_refptr<ExtensionPermissionSet> added(
       ExtensionPermissionSet::CreateDifference(total.get(), existing));
 
   extension_service_->UpdateActivePermissions(extension, total.get());
 
   // Update the granted permissions so we don't auto-disable the extension.
   extension_service_->GrantPermissions(extension);
 
   NotifyPermissionsUpdated(ADDED, extension, added.get());
 }
 
-void ExtensionPermissionsManager::RemovePermissions(
+void ExtensionPermissionsUpdater::RemovePermissions(
     const Extension* extension, const ExtensionPermissionSet* permissions) {
   scoped_refptr<const ExtensionPermissionSet> existing(
       extension->GetActivePermissions());
   scoped_refptr<ExtensionPermissionSet> total(
       ExtensionPermissionSet::CreateDifference(existing, permissions));
   scoped_refptr<ExtensionPermissionSet> removed(
       ExtensionPermissionSet::CreateDifference(existing, total.get()));
 
   // We update the active permissions, and not the granted permissions, because
   // the extension, not the user, removed the permissions. This allows the
   // extension to add them again without prompting the user.
   extension_service_->UpdateActivePermissions(extension, total.get());
 
   NotifyPermissionsUpdated(REMOVED, extension, removed.get());
 }
 
-void ExtensionPermissionsManager::DispatchEvent(
+void ExtensionPermissionsUpdater::DispatchEvent(
     const std::string& extension_id,
     const char* event_name,
     const ExtensionPermissionSet* changed_permissions) {
   Profile* profile = extension_service_->profile();
   if (profile && profile->GetExtensionEventRouter()) {
     ListValue value;
     value.Append(PackPermissionsToValue(changed_permissions));
     std::string json_value;
     base::JSONWriter::Write(&value, false, &json_value);
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id, event_name, json_value, profile, GURL());
   }
 }
 
-void ExtensionPermissionsManager::NotifyPermissionsUpdated(
+void ExtensionPermissionsUpdater::NotifyPermissionsUpdated(
     EventType event_type,
     const Extension* extension,
     const ExtensionPermissionSet* changed) {
   if (!changed || changed->IsEmpty())
     return;
 
   UpdatedExtensionPermissionsInfo::Reason reason;
   const char* event_name = NULL;
 
   if (event_type == REMOVED) {
@@ skipping 59 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   if (!args)
     return false;
 
   scoped_refptr<ExtensionPermissionSet> permissions;
   if (!UnpackPermissionsFromValue(args, &permissions, &bad_message_, &error_))
     return false;
   CHECK(permissions.get());
 
   const Extension* extension = GetExtension();
-  ExtensionPermissionsManager* perms_manager =
-      profile()->GetExtensionService()->permissions_manager();
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
 
   // Make sure they're only trying to remove permissions supported by this API.
   ExtensionAPIPermissionSet apis = permissions->apis();
   for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     const ExtensionAPIPermission* api = info->GetByID(*i);
     if (!api->supports_optional()) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(
           kNotWhitelistedError, api->name());
       return false;
     }
   }
 
   // Make sure we don't remove any required pemissions.
   const ExtensionPermissionSet* required = extension->required_permission_set();
   scoped_refptr<ExtensionPermissionSet> intersection(
       ExtensionPermissionSet::CreateIntersection(permissions.get(), required));
   if (!intersection->IsEmpty()) {
     error_ = kCantRemoveRequiredPermissionsError;
     result_.reset(Value::CreateBooleanValue(false));
     return false;
   }
 
-  perms_manager->RemovePermissions(extension, permissions.get());
+  ExtensionPermissionsUpdater perms_updater(profile()->GetExtensionService());
+  perms_updater.RemovePermissions(extension, permissions.get());
   result_.reset(Value::CreateBooleanValue(true));
   return true;
 }
 
 // static
 void RequestPermissionsFunction::SetAutoConfirmForTests(bool should_proceed) {
   auto_confirm_for_tests = should_proceed ? PROCEED : ABORT;
 }
 
 // static
@@ skipping 14 matching lines @@
   DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   if (!args)
     return false;
 
   if (!UnpackPermissionsFromValue(
           args, &requested_permissions_, &bad_message_, &error_))
     return false;
   CHECK(requested_permissions_.get());
 
-  extension_ = GetExtension();
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
-  ExtensionPermissionsManager* perms_manager =
-      profile()->GetExtensionService()->permissions_manager();
   ExtensionPrefs* prefs = profile()->GetExtensionService()->extension_prefs();
 
   // Make sure they're only requesting permissions supported by this API.
   ExtensionAPIPermissionSet apis = requested_permissions_->apis();
   for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     const ExtensionAPIPermission* api = info->GetByID(*i);
     if (!api->supports_optional()) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(
           kNotWhitelistedError, api->name());
       return false;
     }
   }
 
   // The requested permissions must be defined as optional in the manifest.
-  if (!extension_->optional_permission_set()->Contains(
+  if (!GetExtension()->optional_permission_set()->Contains(
           *requested_permissions_)) {
     error_ = kNotInOptionalPermissionsError;
     result_.reset(Value::CreateBooleanValue(false));
     return false;
   }
 
   // We don't need to prompt the user if the requested permissions are a subset
   // of the granted permissions set.
   const ExtensionPermissionSet* granted =
-      prefs->GetGrantedPermissions(extension_->id());
+      prefs->GetGrantedPermissions(GetExtension()->id());
   if (granted && granted->Contains(*requested_permissions_)) {
-    perms_manager->AddPermissions(extension_, requested_permissions_.get());
+    ExtensionPermissionsUpdater perms_updater(profile()->GetExtensionService());
+    perms_updater.AddPermissions(GetExtension(), requested_permissions_.get());
     result_.reset(Value::CreateBooleanValue(true));
     SendResponse(true);
     return true;
   }
 
   // Filter out the granted permissions so we only prompt for new ones.
   requested_permissions_ = ExtensionPermissionSet::CreateDifference(
       requested_permissions_.get(), granted);
 
-  // Balanced with Release() in InstallUIProceed() and InstallUIAbort().
-  AddRef();
+  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(new ExtensionInstallUI(profile()));
     install_ui_->ConfirmPermissions(
-        this, extension_, requested_permissions_.get());
+        this, GetExtension(), requested_permissions_.get());
   }
 
   return true;
 }
 
 void RequestPermissionsFunction::InstallUIProceed() {
-  ExtensionPermissionsManager* perms_manager =
-      profile()->GetExtensionService()->permissions_manager();
+  ExtensionPermissionsUpdater perms_updater(profile()->GetExtensionService());
+  perms_updater.AddPermissions(GetExtension(), requested_permissions_.get());

[Aaron Boodman, 2011/11/14 19:26:05]

I can't remember - if an extension is unloaded, does GetExtension() start
returning NULL? I think it might. In that case, you'll need to NULL-check this.

[jstritar, 2011/12/12 22:28:03]

The ExtensionFunction has a scoped_refptr to the Extension, so I think it should
stay around.

 
-  install_ui_.reset();
   result_.reset(Value::CreateBooleanValue(true));
-  perms_manager->AddPermissions(extension_, requested_permissions_.get());
-
   SendResponse(true);
 
-  Release();
+  Release();  // Balanced in RunImpl().
 }
 
 void RequestPermissionsFunction::InstallUIAbort(bool user_initiated) {
-  install_ui_.reset();
   result_.reset(Value::CreateBooleanValue(false));
-  requested_permissions_ = NULL;
+  SendResponse(true);
 
-  SendResponse(true);
-  Release();
+  Release();  // Balanced in RunImpl().
 }