Cleanup extension permissions module.

chrome/browser/extensions/extension_service.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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 39 matching lines @@
 #include "chrome/browser/extensions/extension_processes_api.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/extensions/extension_webnavigation_api.h"
 #include "chrome/browser/extensions/external_extension_provider_impl.h"
 #include "chrome/browser/extensions/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
+#include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/history/history_extension_api.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/sync/api/sync_change.h"
@@ skipping 307 matching lines @@
       extension_prefs_(extension_prefs),
       settings_frontend_(extensions::SettingsFrontend::Create(profile)),
       pending_extension_manager_(*ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       install_directory_(install_directory),
       extensions_enabled_(extensions_enabled),
       show_extensions_prompts_(true),
       ready_(false),
       toolbar_model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       menu_manager_(profile),
       app_notification_manager_(new AppNotificationManager(profile)),
-      permissions_manager_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       apps_promo_(profile->GetPrefs()),
       event_routers_initialized_(false),
       extension_warnings_(profile),
       socket_controller_(NULL),
       tracker_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
@@ skipping 500 matching lines @@
 
   SyncExtensionChangeIfNeeded(*extension);
 
   // Deactivating one extension might have solved the problems of others.
   // Therefore, we clear warnings of this type for all extensions.
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
 }
 
-void ExtensionService::GrantPermissions(const Extension* extension) {
-  CHECK(extension);
-
-  // We only maintain the granted permissions prefs for extensions that can't
-  // silently increase their permissions.
-  if (extension->CanSilentlyIncreasePermissions())
-    return;
-
-  extension_prefs_->AddGrantedPermissions(extension->id(),
-                                          extension->GetActivePermissions());
-}
-
 void ExtensionService::GrantPermissionsAndEnableExtension(
     const Extension* extension) {
   CHECK(extension);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_ReEnable");
-  GrantPermissions(extension);
+  extensions::PermissionsUpdater perms_updater(profile());
+  perms_updater.GrantActivePermissions(extension);
   extension_prefs_->SetDidExtensionEscalatePermissions(extension, false);
   EnableExtension(extension->id());
 }
 
-void ExtensionService::UpdateActivePermissions(
-    const Extension* extension,
-    const ExtensionPermissionSet* permissions) {
-  extension_prefs()->SetActivePermissions(extension->id(), permissions);
-  extension->SetActivePermissions(permissions);
-}
-
 // static
 void ExtensionService::RecordPermissionMessagesHistogram(
     const Extension* e, const char* histogram) {
   // Since this is called from multiple sources, and since the Histogram macros
   // use statics, we need to manually lookup the Histogram ourselves.
   base::Histogram* counter = base::LinearHistogram::FactoryGet(
       histogram,
       1,
       ExtensionPermissionMessage::kEnumBoundary,
       ExtensionPermissionMessage::kEnumBoundary + 1,
@@ skipping 1100 matching lines @@
 
     // Make sure the active permissions contain no more than optional + default.
     scoped_refptr<ExtensionPermissionSet> adjusted_active =
         ExtensionPermissionSet::CreateIntersection(
             total_permissions.get(), active_permissions.get());
 
     // Make sure the active permissions contain the default permissions.
     adjusted_active = ExtensionPermissionSet::CreateUnion(
             extension->required_permission_set(), adjusted_active.get());
 
-    UpdateActivePermissions(extension, adjusted_active);
+    extensions::PermissionsUpdater perms_updater(profile());
+    perms_updater.UpdateActivePermissions(extension, adjusted_active);
   }
 
   // We keep track of all permissions the user has granted each extension.
   // This allows extensions to gracefully support backwards compatibility
   // by including unknown permissions in their manifests. When the user
   // installs the extension, only the recognized permissions are recorded.
   // When the unknown permissions become recognized (e.g., through browser
   // upgrade), we can prompt the user to accept these new permissions.
   // Extensions can also silently upgrade to less permissions, and then
   // silently upgrade to a version that adds these permissions back.
@@ skipping 592 matching lines @@
   //
   // To coexist with certain unit tests that don't have an IO thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy a SocketController.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!socket_controller_) {
     socket_controller_ = new extensions::SocketController();
   }
   return socket_controller_;
 }