Track permissions granted to extensions in prefs

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2010 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/extensions_service.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 933 matching lines @@
                                            extension);
   extensions_.erase(iter);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionUnloaded(extension);
   UpdateActiveExtensionsInCrashReporter();
 }
 
+void ExtensionsService::GrantPermissions(const Extension* extension) {
+  DCHECK(extension);
+
+  std::set<std::string> effective_hosts;
+  extension->GetEffectiveHostPermissions().GetAsStringSet(&effective_hosts);
+
+  extension_prefs_->GrantPermissions(extension->id(),
+                                     extension->api_permissions(),
+                                     effective_hosts);
+}
+
+void ExtensionsService::GrantPermissionsAndEnableExtension(
+    const Extension* extension) {
+  DCHECK(extension);
+  GrantPermissions(extension);
+  extension_prefs_->SetDidExtensionEscalatePermissions(extension, false);
+  EnableExtension(extension->id());
+}
+
 void ExtensionsService::LoadExtension(const FilePath& extension_path) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           backend_.get(),
           &ExtensionsServiceBackend::LoadSingleExtension,
           extension_path, scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::LoadComponentExtensions() {
@@ skipping 164 matching lines @@
     ReportExtensionLoadError(info.extension_path,
                              error,
                              NotificationType::EXTENSION_INSTALL_ERROR,
                              false);
     return;
   }
 
   if (write_to_prefs)
     extension_prefs_->UpdateManifest(extension);
 
-  OnExtensionLoaded(extension, true);
-
+  // External extensions are allowed to increase their privileges without
+  // prompting users.
   if (Extension::IsExternalLocation(info.extension_location)) {
+    OnExtensionLoaded(extension, true);
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(
             backend_.get(),
             &ExtensionsServiceBackend::CheckExternalUninstall,
             scoped_refptr<ExtensionsService>(this),
             info.extension_id));
+  } else {
+    OnExtensionLoaded(extension, false);
   }
 }
 
 void ExtensionsService::NotifyExtensionLoaded(const Extension* extension) {
   // The ChromeURLRequestContexts need to be first to know that the extension
   // was loaded, otherwise a race can arise where a renderer that is created
   // for the extension may try to load an extension URL with an extension id
   // that the request context doesn't yet know about. The profile is responsible
   // for ensuring its URLRequestContexts appropriately discover the loaded
   // extension.
@@ skipping 363 matching lines @@
       old = NULL;
 
       if (!allow_silent_upgrade) {
         // Extension has changed permissions significantly. Disable it. We
         // send a notification below.
         extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
         extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
       }
     }
 
+    // For gracefully handling backwards compatibility, extensions are allowed
+    // to have unknown permissions in their manifest. We keep track of the last
+    // known set of permissions, so that we can prompt the user when unknown

[Aaron Boodman, 2010/11/12 00:05:24]

It might be nice to include a little example here to clarify.

[jstritar, 2010/11/19 21:38:36]

I updated the comment to make more sense and added an example. Hopefully the
example isn't too confusing...

+    // permissions become known.
+    if (extension->location() == Extension::INTERNAL) {
+      std::set<std::string> granted_apis;
+      std::set<std::string> granted_hosts;
+
+      // If the granted permissions list hasn't been initialized yet (such
+      // as when migrating from the old scheme) or privilege increases are
+      // allowed, then just grant all recognized permissions.
+      if (!extension_prefs_->GetGrantedPermissions(extension->id(),
+                                                   &granted_apis,
+                                                   &granted_hosts) ||
+          allow_privilege_increase) {
+        GrantPermissions(extension);
+
+      // Here, we disable the extension and prompt the user if the unknown
+      // permissions are now recognized.
+      } else if (Extension::IsPrivilegeIncrease(
+          &granted_apis, &granted_hosts, extension)) {
+        extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
+        extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
+      }
+    }
+
     switch (extension_prefs_->GetExtensionState(extension->id())) {
       case Extension::ENABLED:
         extensions_.push_back(scoped_extension);
 
         NotifyExtensionLoaded(extension);
 
         ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
             extension->GetChromeURLOverrides());
         break;
       case Extension::DISABLED:
@@ skipping 406 matching lines @@
 }
 
 bool ExtensionsService::IsBeingUpgraded(const Extension* extension) {
   return extension_runtime_data_[extension->id()].being_upgraded;
 }
 
 void ExtensionsService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }