Add an experimental permissions API for extensions.

The permissions API lets extensions specify optional permissions in their manifest that they can request at run-time. It currently supports API permissions through a white-list. Host permissions will come later.

BUG=48119, 70466, 84507
TEST=*Extension*

Review URL: http://codereview.chromium.org/7432006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@94288 0039d316-1c4b-4281-b951-d872f2087c98

52 files changed, 4107 insertions, 426 deletions

diff --git a/chrome/app/generated_resources.grd b/chrome/app/generated_resources.grd
index 404e58b..7382d99 100644
--- a/chrome/app/generated_resources.grd
+++ b/chrome/app/generated_resources.grd
@@ -3672,6 +3672,9 @@ are declared in build/common.gypi.
       <message name="IDS_EXTENSION_RE_ENABLE_PROMPT_TITLE" desc="Titlebar of the extension or app prompt window when re-enabling an extension that requires additional permissions">
         Confirm Re-enable
       </message>
+      <message name="IDS_EXTENSION_PERMISSIONS_PROMPT_TITLE" desc="Titlebar of the extension or app permissions prompt window">
+        Confirm Permissions
+      </message>
       <message name="IDS_EXTENSION_INSTALL_PROMPT_HEADING" desc="First bold line in the content area of the extension or app installation prompt. Asks the user if they want to install a particular extension or app.">
         Install <ph name="EXTENSION_NAME">$1<ex>Gmail Checker</ex></ph>?
       </message>
@@ -3681,6 +3684,9 @@ are declared in build/common.gypi.
       <message name="IDS_EXTENSION_RE_ENABLE_PROMPT_HEADING" desc="First bold line in the content area of the extension or app installation prompt. Asks the user if they want to re-enable a particular extension or app.">
         The newest version of "<ph name="EXTENSION_NAME">$1<ex>Gmail Checker</ex></ph>" has been disabled because it requires more permissions.
       </message>
+      <message name="IDS_EXTENSION_PERMISSIONS_PROMPT_HEADING" desc="First bold line in the content area of the extension or app permissions prompt. Asks the user if they want to grant the permissions to the particular extension or app.">
+        The extension "<ph name="EXTENSION_NAME">$1<ex>Gmail Checker</ex></ph>" has requested additional permissions.
+      </message>
 
       <!-- Extension/App install dialog strings -->
       <message name="IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO" desc="Second line in the content area of the extension or app installation prompt. Note that the exact wording is important. This should mean that the extension or app _can_ access the listed privileges, but not necessarily that it will or needs to.">
@@ -3689,6 +3695,10 @@ are declared in build/common.gypi.
       <message name="IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO" desc="Second line in the content area of the extension or app re-enable prompt. Note that the exact wording is important. This should mean that the extension _can now_ access the listed privileges, but not necessarily that it will or needs to. This message appeared because the user must approve new permissions of the extension or app.">
         It can now access:
       </message>
+      <message name="IDS_EXTENSION_PROMPT_WANTS_ACCESS_TO" desc="Second line in the content area of the extension or app permissions prompt. Note that the exact wording is important. This should mean that the extension _wants to_ access the listed privileges, but not necessarily that it will or needs to. This message appeared because the user must approve new permissions of the extension or app.">
+        It could access:
+      </message>
+
       <message name="IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS" desc="Permission string for full access to the computer and all websites.">
         All data on your computer and the websites you visit
       </message>
@@ -4033,6 +4043,12 @@ Keep your key file in a safe place. You will need it to create new versions of y
       <message name="IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON" desc="Text for the enable button on the extension re-enable prompt">
         Re-enable
       </message>
+      <message name="IDS_EXTENSION_PROMPT_PERMISSIONS_BUTTON" desc="Text for the allow button on the extension permissions prompt">
+        Allow
+      </message>
+      <message name="IDS_EXTENSION_PROMPT_PERMISSIONS_ABORT_BUTTON" desc="Text for the deny button on the extension permissions prompt">
+        Deny
+      </message>
       <message name="IDS_EXTENSION_WEB_STORE_TITLE" desc="Text for the Chrome Web Store">
         Web Store
       </message>
@@ -7736,7 +7752,7 @@ Keep your key file in a safe place. You will need it to create new versions of y
       <message name="IDS_AUTOFILL_HELP_LABEL" desc="The label of the Help link on the Autofill dialog.">
         About Autofill
       </message>
-      
+
       <message name="IDS_AUTOFILL_SHOW_PREDICTIONS_TITLE" desc="The title for form elements when annotated with Autofill predictions.">
         heuristic type: <ph name="HEURISTIC_TYPE">$1<ex>NAME_FIRST</ex></ph>\nserver type: <ph name="SERVER_TYPE">$2<ex>NAME_FIRST</ex></ph>\nfield signature: <ph name="FIELD_SIGNATURE">$3<ex>12345678</ex></ph>\nform signature: <ph name="FORM_SIGNATURE">$4<ex>1234567812345678</ex></ph>\nexperiment id: "<ph name="EXPERIMENT_ID">$5<ex>ar1</ex></ph>"
       </message>
@@ -8287,7 +8303,7 @@ Keep your key file in a safe place. You will need it to create new versions of y
       </message>
       <message name="IDS_APP_DEFAULT_PAGE_NAME"
                desc="Default name for the first 'Apps' page on the New Tab Page.">
-        Apps 
+        Apps
       </message>
       <message name="IDS_APP_CONTEXT_MENU_OPEN_PINNED"
                desc="Text for the button that opens the app in a pinned tab.">
diff --git a/chrome/browser/automation/testing_automation_provider.cc b/chrome/browser/automation/testing_automation_provider.cc
index 44a3b5b..d1a523f 100644
--- a/chrome/browser/automation/testing_automation_provider.cc
+++ b/chrome/browser/automation/testing_automation_provider.cc
@@ -4111,7 +4111,7 @@ ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
   if (effective_perm)
     pattern_set = ext->GetEffectiveHostPermissions();
   else
-    pattern_set = ext->permission_set()->explicit_hosts();
+    pattern_set = ext->GetActivePermissions()->explicit_hosts();
 
   ListValue* permissions = new ListValue;
   for (URLPatternSet::const_iterator perm = pattern_set.begin();
@@ -4124,7 +4124,8 @@ ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
 
 ListValue* GetAPIPermissions(const Extension* ext) {
   ListValue* permissions = new ListValue;
-  std::set<std::string> perm_list = ext->permission_set()->GetAPIsAsStrings();
+  std::set<std::string> perm_list =
+      ext->GetActivePermissions()->GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
        perm != perm_list.end(); ++perm) {
     permissions->Append(new StringValue(perm->c_str()));
diff --git a/chrome/browser/background/background_mode_manager.cc b/chrome/browser/background/background_mode_manager.cc
index c44362c..33eecf1 100644
--- a/chrome/browser/background/background_mode_manager.cc
+++ b/chrome/browser/background/background_mode_manager.cc
@@ -196,13 +196,15 @@ void BackgroundModeManager::RegisterProfile(Profile* profile) {
                                                 profile, this));
   background_mode_data_[profile] = bmd;
 
-  // Listen for when extensions are loaded/unloaded so we can track the
-  // number of background apps and modify our keep-alive and launch-on-startup
-  // state appropriately.
+  // Listen for when extensions are loaded/unloaded or add/remove the
+  // background permission so we can track the number of background apps and
+  // modify our keep-alive and launch-on-startup state appropriately.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  Source<Profile>(profile));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  Source<Profile>(profile));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED,
+                 Source<Profile>(profile));
 
   // Check for the presence of background apps after all extensions have been
   // loaded, to handle the case where an extension has been manually removed
@@ -274,6 +276,22 @@ void BackgroundModeManager::Observe(int type,
         OnBackgroundAppUninstalled();
       }
       break;
+    case chrome::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED: {
+        UpdatedExtensionPermissionsInfo* info =
+            Details<UpdatedExtensionPermissionsInfo>(details).ptr();
+        if (!info->permissions->HasAPIPermission(
+                ExtensionAPIPermission::kBackground))
+          break;
+
+        if (info->reason == UpdatedExtensionPermissionsInfo::ADDED) {
+          OnBackgroundAppInstalled(info->extension);
+          OnBackgroundAppLoaded();
+        } else {
+          OnBackgroundAppUnloaded();
+          OnBackgroundAppUninstalled();
+        }
+      }
+      break;
     case content::NOTIFICATION_APP_TERMINATING:
       // Make sure we aren't still keeping the app alive (only happens if we
       // don't receive an EXTENSIONS_READY notification for some reason).
diff --git a/chrome/browser/extensions/convert_web_app_browsertest.cc b/chrome/browser/extensions/convert_web_app_browsertest.cc
index a8405b1..7fe6f94 100644
--- a/chrome/browser/extensions/convert_web_app_browsertest.cc
+++ b/chrome/browser/extensions/convert_web_app_browsertest.cc
@@ -70,7 +70,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionFromWebAppTest, Basic) {
   EXPECT_EQ(extension_misc::LAUNCH_PANEL,
             installed_extension_->launch_container());
 
-  ASSERT_EQ(2u, installed_extension_->permission_set()->apis().size());
+  ASSERT_EQ(2u, installed_extension_->GetActivePermissions()->apis().size());
   EXPECT_TRUE(installed_extension_->HasAPIPermission(
       ExtensionAPIPermission::kGeolocation));
   EXPECT_TRUE(installed_extension_->HasAPIPermission(
diff --git a/chrome/browser/extensions/convert_web_app_unittest.cc b/chrome/browser/extensions/convert_web_app_unittest.cc
index 0f3b537..640b31b 100644
--- a/chrome/browser/extensions/convert_web_app_unittest.cc
+++ b/chrome/browser/extensions/convert_web_app_unittest.cc
@@ -123,7 +123,7 @@ TEST(ExtensionFromWebApp, Basic) {
   EXPECT_EQ(UTF16ToUTF8(web_app.title), extension->name());
   EXPECT_EQ(UTF16ToUTF8(web_app.description), extension->description());
   EXPECT_EQ(web_app.app_url, extension->GetFullLaunchURL());
-  EXPECT_EQ(2u, extension->permission_set()->apis().size());
+  EXPECT_EQ(2u, extension->GetActivePermissions()->apis().size());
   EXPECT_TRUE(extension->HasAPIPermission("geolocation"));
   EXPECT_TRUE(extension->HasAPIPermission("notifications"));
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
@@ -167,7 +167,7 @@ TEST(ExtensionFromWebApp, Minimal) {
   EXPECT_EQ("", extension->description());
   EXPECT_EQ(web_app.app_url, extension->GetFullLaunchURL());
   EXPECT_EQ(0u, extension->icons().map().size());
-  EXPECT_EQ(0u, extension->permission_set()->apis().size());
+  EXPECT_EQ(0u, extension->GetActivePermissions()->apis().size());
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
   EXPECT_EQ("*://aaronboodman.com/*",
             extension->web_extent().patterns().begin()->GetAsString());
diff --git a/chrome/browser/extensions/extension_function_dispatcher.cc b/chrome/browser/extensions/extension_function_dispatcher.cc
index c8cbf9e..15529b2 100644
--- a/chrome/browser/extensions/extension_function_dispatcher.cc
+++ b/chrome/browser/extensions/extension_function_dispatcher.cc
@@ -32,6 +32,7 @@
 #include "chrome/browser/extensions/extension_module.h"
 #include "chrome/browser/extensions/extension_omnibox_api.h"
 #include "chrome/browser/extensions/extension_page_actions_module.h"
+#include "chrome/browser/extensions/extension_permissions_api.h"
 #include "chrome/browser/extensions/extension_preference_api.h"
 #include "chrome/browser/extensions/extension_processes_api.h"
 #include "chrome/browser/extensions/extension_proxy_api.h"
@@ -393,6 +394,12 @@ void FactoryRegistry::ResetFunctions() {
   // Experimental App API.
   RegisterFunction<AppNotifyFunction>();
   RegisterFunction<AppClearAllNotificationsFunction>();
+
+  // Permissions
+  RegisterFunction<ContainsPermissionsFunction>();
+  RegisterFunction<GetAllPermissionsFunction>();
+  RegisterFunction<RemovePermissionsFunction>();
+  RegisterFunction<RequestPermissionsFunction>();
 }
 
 void FactoryRegistry::GetAllNames(std::vector<std::string>* names) {
diff --git a/chrome/browser/extensions/extension_install_ui.cc b/chrome/browser/extensions/extension_install_ui.cc
index 62d904a..bdbd839 100644
--- a/chrome/browser/extensions/extension_install_ui.cc
+++ b/chrome/browser/extensions/extension_install_ui.cc
@@ -39,22 +39,32 @@
 // static
 const int ExtensionInstallUI::kTitleIds[NUM_PROMPT_TYPES] = {
   IDS_EXTENSION_INSTALL_PROMPT_TITLE,
-  IDS_EXTENSION_RE_ENABLE_PROMPT_TITLE
+  IDS_EXTENSION_RE_ENABLE_PROMPT_TITLE,
+  IDS_EXTENSION_PERMISSIONS_PROMPT_TITLE
 };
 // static
 const int ExtensionInstallUI::kHeadingIds[NUM_PROMPT_TYPES] = {
   IDS_EXTENSION_INSTALL_PROMPT_HEADING,
-  IDS_EXTENSION_RE_ENABLE_PROMPT_HEADING
+  IDS_EXTENSION_RE_ENABLE_PROMPT_HEADING,
+  IDS_EXTENSION_PERMISSIONS_PROMPT_HEADING
 };
 // static
 const int ExtensionInstallUI::kButtonIds[NUM_PROMPT_TYPES] = {
   IDS_EXTENSION_PROMPT_INSTALL_BUTTON,
-  IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON
+  IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON,
+  IDS_EXTENSION_PROMPT_PERMISSIONS_BUTTON
+};
+// static
+const int ExtensionInstallUI::kAbortButtonIds[NUM_PROMPT_TYPES] = {
+  0,
+  0,
+  IDS_EXTENSION_PROMPT_PERMISSIONS_ABORT_BUTTON
 };
 // static
 const int ExtensionInstallUI::kWarningIds[NUM_PROMPT_TYPES] = {
   IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
-  IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO
+  IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO,
+  IDS_EXTENSION_PROMPT_WANTS_ACCESS_TO,
 };
 
 namespace {
@@ -112,6 +122,7 @@ void ExtensionInstallUI::ConfirmInstall(Delegate* delegate,
                                         const Extension* extension) {
   DCHECK(ui_loop_ == MessageLoop::current());
   extension_ = extension;
+  permissions_ = extension->GetActivePermissions();
   delegate_ = delegate;
 
   // We special-case themes to not show any confirm UI. Instead they are
@@ -129,11 +140,24 @@ void ExtensionInstallUI::ConfirmReEnable(Delegate* delegate,
                                          const Extension* extension) {
   DCHECK(ui_loop_ == MessageLoop::current());
   extension_ = extension;
+  permissions_ = extension->GetActivePermissions();
   delegate_ = delegate;
 
   ShowConfirmation(RE_ENABLE_PROMPT);
 }
 
+void ExtensionInstallUI::ConfirmPermissions(
+    Delegate* delegate,
+    const Extension* extension,
+    const ExtensionPermissionSet* permissions) {
+  DCHECK(ui_loop_ == MessageLoop::current());
+  extension_ = extension;
+  permissions_ = permissions;
+  delegate_ = delegate;
+
+  ShowConfirmation(PERMISSIONS_PROMPT);
+}
+
 void ExtensionInstallUI::OnInstallSuccess(const Extension* extension,
                                           SkBitmap* icon) {
   extension_ = extension;
@@ -193,6 +217,7 @@ void ExtensionInstallUI::OnImageLoaded(
   SetIcon(image);
 
   switch (prompt_type_) {
+    case PERMISSIONS_PROMPT:
     case RE_ENABLE_PROMPT:
     case INSTALL_PROMPT: {
       // TODO(jcivelli): http://crbug.com/44771 We should not show an install
@@ -203,7 +228,7 @@ void ExtensionInstallUI::OnImageLoaded(
           NotificationService::NoDetails());
 
       std::vector<string16> warnings =
-          extension_->GetPermissionMessageStrings();
+          permissions_->GetWarningMessages();
       ShowExtensionInstallDialog(
           profile_, delegate_, extension_, &icon_, warnings, prompt_type_);
       break;
diff --git a/chrome/browser/extensions/extension_install_ui.h b/chrome/browser/extensions/extension_install_ui.h
index 222f6a3..19965e5 100644
--- a/chrome/browser/extensions/extension_install_ui.h
+++ b/chrome/browser/extensions/extension_install_ui.h
@@ -16,6 +16,7 @@
 #include "ui/gfx/native_widget_types.h"
 
 class Extension;
+class ExtensionPermissionSet;
 class MessageLoop;
 class Profile;
 class InfoBarDelegate;
@@ -28,6 +29,7 @@ class ExtensionInstallUI : public ImageLoadingTracker::Observer {
     UNSET_PROMPT_TYPE = -1,
     INSTALL_PROMPT = 0,
     RE_ENABLE_PROMPT,
+    PERMISSIONS_PROMPT,
     NUM_PROMPT_TYPES
   };
 
@@ -36,6 +38,7 @@ class ExtensionInstallUI : public ImageLoadingTracker::Observer {
   static const int kHeadingIds[NUM_PROMPT_TYPES];
   static const int kButtonIds[NUM_PROMPT_TYPES];
   static const int kWarningIds[NUM_PROMPT_TYPES];
+  static const int kAbortButtonIds[NUM_PROMPT_TYPES];
 
   class Delegate {
    public:
@@ -65,6 +68,14 @@ class ExtensionInstallUI : public ImageLoadingTracker::Observer {
   // We *MUST* eventually call either Proceed() or Abort() on |delegate|.
   virtual void ConfirmReEnable(Delegate* delegate, const Extension* extension);
 
+  // This is called by the extension permissions API to verify whether an
+  // extension may be granted additional permissions.
+  //
+  // We *MUST* eventually call either Proceed() or Abort() on |delegate|.
+  virtual void ConfirmPermissions(Delegate* delegate,
+                                  const Extension* extension,
+                                  const ExtensionPermissionSet* permissions);
+
   // Installation was successful. This is declared virtual for testing.
   virtual void OnInstallSuccess(const Extension* extension, SkBitmap* icon);
 
@@ -122,6 +133,9 @@ class ExtensionInstallUI : public ImageLoadingTracker::Observer {
   // The extension we are showing the UI for.
   const Extension* extension_;
 
+  // The permissions being prompted for.
+  scoped_refptr<const ExtensionPermissionSet> permissions_;
+
   // The delegate we will call Proceed/Abort on after confirmation UI.
   Delegate* delegate_;
 
diff --git a/chrome/browser/extensions/extension_management_api.cc b/chrome/browser/extensions/extension_management_api.cc
index 3955361..8037f56 100644
--- a/chrome/browser/extensions/extension_management_api.cc
+++ b/chrome/browser/extensions/extension_management_api.cc
@@ -92,7 +92,7 @@ static DictionaryValue* CreateExtensionInfo(const Extension& extension,
   }
 
   const std::set<std::string> perms =
-      extension.permission_set()->GetAPIsAsStrings();
+      extension.GetActivePermissions()->GetAPIsAsStrings();
   ListValue* permission_list = new ListValue();
   if (!perms.empty()) {
     std::set<std::string>::const_iterator perms_iter;
@@ -107,7 +107,7 @@ static DictionaryValue* CreateExtensionInfo(const Extension& extension,
   if (!extension.is_hosted_app()) {
     // Skip host permissions for hosted apps.
     const URLPatternSet host_perms =
-        extension.permission_set()->explicit_hosts();
+        extension.GetActivePermissions()->explicit_hosts();
     if (!host_perms.is_empty()) {
       URLPatternSet::const_iterator host_perms_iter;
       for (host_perms_iter = host_perms.begin();
diff --git a/chrome/browser/extensions/extension_permissions_api.cc b/chrome/browser/extensions/extension_permissions_api.cc
new file mode 100644
index 0000000..a9a6d23
--- /dev/null
+++ b/chrome/browser/extensions/extension_permissions_api.cc
@@ -0,0 +1,374 @@
+// 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/stringprintf.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_permissions_api_constants.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_messages.h"
+#include "chrome/common/extensions/extension_permission_set.h"
+#include "chrome/common/extensions/url_pattern_set.h"
+#include "content/common/notification_service.h"
+#include "googleurl/src/gurl.h"
+
+
+namespace keys = extension_permissions_module_constants;
+
+namespace {
+
+enum AutoConfirmForTest {
+  DO_NOT_SKIP = 0,
+  PROCEED,
+  ABORT
+};
+AutoConfirmForTest auto_confirm_for_tests = DO_NOT_SKIP;
+
+DictionaryValue* PackPermissionsToValue(const ExtensionPermissionSet* set) {
+  DictionaryValue* value = new DictionaryValue();
+
+  // Generate the list of API permissions.
+  ListValue* apis = new ListValue();
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  for (ExtensionAPIPermissionSet::const_iterator i = set->apis().begin();
+       i != set->apis().end(); ++i)
+    apis->Append(Value::CreateStringValue(info->GetByID(*i)->name()));
+
+  // TODO(jstritar): Include hosts once the API supports them. At that point,
+  // we could also shared this code with ExtensionPermissionSet methods in
+  // ExtensionPrefs.
+
+  value->Set(keys::kApisKey, apis);
+  return value;
+}
+
+// Creates a new ExtensionPermissionSet from its |value| and passes ownership to
+// the caller through |ptr|. Sets |bad_message| to true if the message is badly
+// formed. Returns false if the method fails to unpack a permission set.
+bool UnpackPermissionsFromValue(DictionaryValue* value,
+                                scoped_refptr<ExtensionPermissionSet>* ptr,
+                                bool* bad_message,
+                                std::string* error) {
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  ExtensionAPIPermissionSet apis;
+  if (value->HasKey(keys::kApisKey)) {
+    ListValue* api_list = NULL;
+    if (!value->GetList(keys::kApisKey, &api_list)) {
+      *bad_message = true;
+      return false;
+    }
+    for (size_t i = 0; i < api_list->GetSize(); ++i) {
+      std::string api_name;
+      if (!api_list->GetString(i, &api_name)) {
+        *bad_message = true;
+        return false;
+      }
+
+      ExtensionAPIPermission* permission = info->GetByName(api_name);
+      if (!permission) {
+        *error = base::StringPrintf(
+            keys::kUnknownPermissionError, api_name.c_str());
+        return false;
+      }
+      apis.insert(permission->id());
+    }
+  }
+
+  // Ignore host permissions for now.
+  URLPatternSet empty_set;
+  *ptr = new ExtensionPermissionSet(apis, empty_set, empty_set);
+  return true;
+}
+
+} // namespace
+
+ExtensionPermissionsManager::ExtensionPermissionsManager(
+    ExtensionService* extension_service)
+    : extension_service_(extension_service) {
+  RegisterWhitelist();
+}
+
+ExtensionPermissionsManager::~ExtensionPermissionsManager() {
+}
+
+void ExtensionPermissionsManager::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(extension, total.get(), added.get(), ADDED);
+}
+
+void ExtensionPermissionsManager::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(extension, total.get(), removed.get(), REMOVED);
+}
+
+void ExtensionPermissionsManager::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(
+    const Extension* extension,
+    const ExtensionPermissionSet* active,
+    const ExtensionPermissionSet* changed,
+    EventType event_type) {
+  if (!changed || changed->IsEmpty())
+    return;
+
+  UpdatedExtensionPermissionsInfo::Reason reason;
+  const char* event_name = NULL;
+
+  if (event_type == REMOVED) {
+    reason = UpdatedExtensionPermissionsInfo::REMOVED;
+    event_name = keys::kOnRemoved;
+  } else {
+    CHECK_EQ(ADDED, event_type);
+    reason = UpdatedExtensionPermissionsInfo::ADDED;
+    event_name = keys::kOnAdded;
+  }
+
+  // Notify other APIs or interested parties.
+  UpdatedExtensionPermissionsInfo info = UpdatedExtensionPermissionsInfo(
+      extension, changed, reason);
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED,
+      Source<Profile>(extension_service_->profile()),
+      Details<UpdatedExtensionPermissionsInfo>(&info));
+
+  // Trigger the onAdded and onRemoved events in the extension.
+  DispatchEvent(extension->id(), event_name, changed);
+
+  // Send the new permissions to the renderers.
+  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance()) {
+    RenderProcessHost* host = i.GetCurrentValue();
+    if (extension_service_->profile()->IsSameProfile(host->profile()))
+      host->Send(new ExtensionMsg_UpdatePermissions(
+          extension->id(),
+          active->apis(),
+          active->explicit_hosts(),
+          active->scriptable_hosts()));
+  }
+}
+
+void ExtensionPermissionsManager::RegisterWhitelist() {
+  // TODO(jstritar): This could be a field on ExtensionAPIPermission.
+  ExtensionAPIPermissionSet api_whitelist;
+  api_whitelist.insert(ExtensionAPIPermission::kClipboardRead);
+  api_whitelist.insert(ExtensionAPIPermission::kClipboardWrite);
+  api_whitelist.insert(ExtensionAPIPermission::kNotification);
+  api_whitelist.insert(ExtensionAPIPermission::kBookmark);
+  api_whitelist.insert(ExtensionAPIPermission::kContextMenus);
+  api_whitelist.insert(ExtensionAPIPermission::kCookie);
+  api_whitelist.insert(ExtensionAPIPermission::kDebugger);
+  api_whitelist.insert(ExtensionAPIPermission::kHistory);
+  api_whitelist.insert(ExtensionAPIPermission::kIdle);
+  api_whitelist.insert(ExtensionAPIPermission::kTab);
+  api_whitelist.insert(ExtensionAPIPermission::kManagement);
+  api_whitelist.insert(ExtensionAPIPermission::kBackground);
+  whitelist_ = new ExtensionPermissionSet(
+      api_whitelist, URLPatternSet(), URLPatternSet());
+}
+
+bool ContainsPermissionsFunction::RunImpl() {
+  DictionaryValue* args = NULL;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
+  std::string error;
+  if (!args)
+    return false;
+
+  scoped_refptr<ExtensionPermissionSet> permissions;
+  if (!UnpackPermissionsFromValue(args, &permissions, &bad_message_, &error_))
+    return false;
+  CHECK(permissions.get());
+
+  result_.reset(Value::CreateBooleanValue(
+      GetExtension()->GetActivePermissions()->Contains(*permissions)));
+  return true;
+}
+
+bool GetAllPermissionsFunction::RunImpl() {
+  result_.reset(PackPermissionsToValue(
+      GetExtension()->GetActivePermissions()));
+  return true;
+}
+
+bool RemovePermissionsFunction::RunImpl() {
+  DictionaryValue* args = NULL;
+  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.
+  scoped_refptr<ExtensionPermissionSet> unsupported(
+      ExtensionPermissionSet::CreateDifference(
+          permissions.get(), &perms_manager->whitelist()));
+  if (unsupported->apis().size()) {
+    std::string api_name = info->GetByID(*unsupported->apis().begin())->name();
+    error_ = base::StringPrintf(keys::kNotWhitelistedError, api_name.c_str());
+    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_ = keys::kCantRemoveRequiredPermissionsError;
+    result_.reset(Value::CreateBooleanValue(false));
+    return false;
+  }
+
+  perms_manager->RemovePermissions(extension, permissions.get());
+  result_.reset(Value::CreateBooleanValue(true));
+  return true;
+}
+
+void RequestPermissionsFunction::SetAutoConfirmForTests(bool should_proceed) {
+  auto_confirm_for_tests = should_proceed ? PROCEED : ABORT;
+}
+
+bool RequestPermissionsFunction::RunImpl() {
+  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 only white listed permissions have been requested.
+  scoped_refptr<ExtensionPermissionSet> unsupported(
+      ExtensionPermissionSet::CreateDifference(
+          requested_permissions_.get(), &perms_manager->whitelist()));
+  if (unsupported->apis().size()) {
+    std::string api_name = info->GetByID(*unsupported->apis().begin())->name();
+    error_ = base::StringPrintf(keys::kNotWhitelistedError, api_name.c_str());
+    return false;
+  }
+
+  // The requested permissions must be defined as optional in the manifest.
+  if (!extension_->optional_permission_set()->Contains(
+          *requested_permissions_)) {
+    error_ = keys::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());
+  if (granted && granted->Contains(*requested_permissions_)) {
+    perms_manager->AddPermissions(extension_, 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();
+
+  // 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());
+  }
+
+  return true;
+}
+
+void RequestPermissionsFunction::InstallUIProceed() {
+  ExtensionPermissionsManager* perms_manager =
+      profile()->GetExtensionService()->permissions_manager();
+
+  install_ui_.reset();
+  result_.reset(Value::CreateBooleanValue(true));
+  perms_manager->AddPermissions(extension_, requested_permissions_.get());
+
+  SendResponse(true);
+
+  Release();
+}
+
+void RequestPermissionsFunction::InstallUIAbort(bool user_initiated) {
+  install_ui_.reset();
+  result_.reset(Value::CreateBooleanValue(false));
+  requested_permissions_ = NULL;
+
+  SendResponse(true);
+  Release();
+}
diff --git a/chrome/browser/extensions/extension_permissions_api.h b/chrome/browser/extensions/extension_permissions_api.h
new file mode 100644
index 0000000..15b0769
--- /dev/null
+++ b/chrome/browser/extensions/extension_permissions_api.h
@@ -0,0 +1,117 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PERMISSIONS_API_H__
+#define CHROME_BROWSER_EXTENSIONS_EXTENSION_PERMISSIONS_API_H__
+#pragma once
+
+#include "chrome/browser/extensions/extension_function.h"
+#include "chrome/browser/extensions/extension_install_ui.h"
+#include "chrome/common/extensions/extension_permission_set.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/browser/renderer_host/render_process_host.h"
+#include "content/common/notification_service.h"
+
+namespace base {
+class DictionaryValue;
+}
+class Extension;
+class ExtensionPermissionSet;
+class ExtensionService;
+class Profile;
+
+class ExtensionPermissionsManager {
+ public:
+  explicit ExtensionPermissionsManager(ExtensionService* extension_service);
+  ~ExtensionPermissionsManager();
+
+  // Adds the set of |permissions| to the |extension|'s active permission set
+  // and sends the relevant messages and notifications. This method assumes the
+  // user has already been prompted, if necessary, for the extra permissions.
+  void AddPermissions(const Extension* extension,
+                      const ExtensionPermissionSet* permissions);
+
+  // Removes the set of |permissions| from the |extension|'s active permission
+  // set and sends the relevant messages and notifications.
+  void RemovePermissions(const Extension* extension,
+                         const ExtensionPermissionSet* permissions);
+
+  // Returns the list of API permissions that are supported by the optional
+  // permissions API.
+  const ExtensionPermissionSet& whitelist() const { return *whitelist_; }
+
+ private:
+  enum EventType {
+    ADDED,
+    REMOVED,
+  };
+
+  // Dispatches specified event to the extension.
+  void DispatchEvent(const std::string& extension_id,
+                     const char* event_name,
+                     const ExtensionPermissionSet* changed_permissions);
+
+  // Issues the relevant events, messages and notifications when the permissions
+  // have changed for the |extension| (|changed| is the permission delta, while
+  // |active| is the new permission set). Specifically, this sends the
+  // EXTENSION_PERMISSIONS_UPDATED notification, the
+  // ExtensionMsg_UpdatePermissions IPC message, and fires the onAdded/onRemoved
+  // events in the extension.
+  void NotifyPermissionsUpdated(const Extension* extension,
+                                const ExtensionPermissionSet* active,
+                                const ExtensionPermissionSet* changed,
+                                EventType event_type);
+
+  // Registers the list of APIs supported by the optional permissions API.
+  void RegisterWhitelist();
+
+  ExtensionService* extension_service_;
+  scoped_refptr<ExtensionPermissionSet> whitelist_;
+};
+
+
+// chrome.permissions.contains
+class ContainsPermissionsFunction : public SyncExtensionFunction {
+  virtual ~ContainsPermissionsFunction() {}
+  virtual bool RunImpl() OVERRIDE;
+  DECLARE_EXTENSION_FUNCTION_NAME("experimental.permissions.contains")
+};
+
+// chrome.permissions.getAll
+class GetAllPermissionsFunction : public SyncExtensionFunction {
+  virtual ~GetAllPermissionsFunction() {}
+  virtual bool RunImpl() OVERRIDE;
+  DECLARE_EXTENSION_FUNCTION_NAME("experimental.permissions.getAll")
+};
+
+// chrome.permissions.remove
+class RemovePermissionsFunction : public SyncExtensionFunction {
+  virtual ~RemovePermissionsFunction() {}
+  virtual bool RunImpl() OVERRIDE;
+  DECLARE_EXTENSION_FUNCTION_NAME("experimental.permissions.remove")
+};
+
+// chrome.permissions.request
+class RequestPermissionsFunction : public AsyncExtensionFunction,
+                                   public ExtensionInstallUI::Delegate {
+ public:
+  // FOR TESTS ONLY to bypass the confirmation UI.
+  static void SetAutoConfirmForTests(bool should_proceed);
+
+  // Implementing ExtensionInstallUI::Delegate interface.
+  virtual void InstallUIProceed() OVERRIDE;
+  virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
+
+ protected:
+  virtual ~RequestPermissionsFunction() {}
+  virtual bool RunImpl() OVERRIDE;
+
+ private:
+  scoped_ptr<ExtensionInstallUI> install_ui_;
+  scoped_refptr<ExtensionPermissionSet> requested_permissions_;
+  const Extension* extension_;
+  DECLARE_EXTENSION_FUNCTION_NAME("experimental.permissions.request")
+};
+
+#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PERMISSIONS_API_H__
diff --git a/chrome/browser/extensions/extension_permissions_api_constants.cc b/chrome/browser/extensions/extension_permissions_api_constants.cc
new file mode 100644
index 0000000..5d75ccd
--- /dev/null
+++ b/chrome/browser/extensions/extension_permissions_api_constants.cc
@@ -0,0 +1,23 @@
+// 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_constants.h"
+
+namespace extension_permissions_module_constants {
+
+const char kApisKey[] = "permissions";
+
+const char kCantRemoveRequiredPermissionsError[] =
+    "You cannot remove required permissions.";
+const char kNotInOptionalPermissionsError[] =
+    "Optional permissions must be listed in extension manifest.";
+const char kNotWhitelistedError[] =
+    "The optional permissions API does not support '%s'.";
+const char kUnknownPermissionError[] =
+    "'%s' is not a recognized permission.";
+
+const char kOnAdded[] = "experimental.permissions.onAdded";
+const char kOnRemoved[] = "experimental.permissions.onRemoved";
+
+};  // namespace extension_permissions_module_constants
diff --git a/chrome/browser/extensions/extension_permissions_api_constants.h b/chrome/browser/extensions/extension_permissions_api_constants.h
new file mode 100644
index 0000000..64b5116
--- /dev/null
+++ b/chrome/browser/extensions/extension_permissions_api_constants.h
@@ -0,0 +1,28 @@
+// 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.
+
+// Constants used for the Tabs API and the Windows API.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PERMISSIONS_API_CONSTANTS_H_
+#define CHROME_BROWSER_EXTENSIONS_EXTENSION_PERMISSIONS_API_CONSTANTS_H_
+#pragma once
+
+namespace extension_permissions_module_constants {
+
+// Keys used in serializing permissions data and events.
+extern const char kApisKey[];
+
+// Error messages.
+extern const char kCantRemoveRequiredPermissionsError[];
+extern const char kNotInOptionalPermissionsError[];
+extern const char kNotWhitelistedError[];
+extern const char kUnknownPermissionError[];
+
+// Event names.
+extern const char kOnAdded[];
+extern const char kOnRemoved[];
+
+};  // namespace extension_permissions_module_constants
+
+#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PERMISSIONS_API_CONSTANTS_H_
diff --git a/chrome/browser/extensions/extension_prefs.cc b/chrome/browser/extensions/extension_prefs.cc
index 334b64f..e0a8d6e 100644
--- a/chrome/browser/extensions/extension_prefs.cc
+++ b/chrome/browser/extensions/extension_prefs.cc
@@ -102,11 +102,15 @@ const char kBrowserActionVisible[] = "browser_action_visible";
 // Preferences that hold which permissions the user has granted the extension.
 // We explicitly keep track of these so that extensions can contain unknown
 // permissions, for backwards compatibility reasons, and we can still prompt
-// the user to accept them once recognized.
-const char kPrefGrantedAPIs[] = "granted_permissions.api";
-const char kPrefGrantedExplicitHosts[] = "granted_permissions.explicit_host";
-const char kPrefGrantedScriptableHosts[] =
-    "granted_permissions.scriptable_host";
+// the user to accept them once recognized. We store the active permission
+// permissions because they may differ from those defined in the manifest.
+const char kPrefActivePermissions[] = "active_permissions";
+const char kPrefGrantedPermissions[] = "granted_permissions";
+
+// The preference names for ExtensionPermissionSet values.
+const char kPrefAPIs[] = "api";
+const char kPrefExplicitHosts[] = "explicit_host";
+const char kPrefScriptableHosts[] = "scriptable_host";
 
 // The preference names for the old granted permissions scheme.
 const char kPrefOldGrantedFullAccess[] = "granted_permissions.full";
@@ -206,6 +210,10 @@ class ScopedExtensionControlledPrefUpdate : public DictionaryPrefUpdate {
   DISALLOW_COPY_AND_ASSIGN(ScopedExtensionControlledPrefUpdate);
 };
 
+std::string JoinPrefs(std::string parent, const char* child) {
+  return parent + "." + child;
+}
+
 }  // namespace
 
 ExtensionPrefs::ExtensionPrefs(
@@ -423,6 +431,75 @@ void ExtensionPrefs::SetExtensionPrefURLPatternSet(
   UpdateExtensionPref(extension_id, pref_key, value);
 }
 
+ExtensionPermissionSet* ExtensionPrefs::ReadExtensionPrefPermissionSet(
+    const std::string& extension_id,
+    const std::string& pref_key) {
+  if (!GetExtensionPref(extension_id))
+    return NULL;
+
+  // Retrieve the API permissions.
+  ExtensionAPIPermissionSet apis;
+  const ListValue* api_values = NULL;
+  std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
+  if (ReadExtensionPrefList(extension_id, api_pref, &api_values)) {
+    ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+    for (size_t i = 0; i < api_values->GetSize(); ++i) {
+      std::string permission_name;
+      if (api_values->GetString(i, &permission_name)) {
+        ExtensionAPIPermission *permission = info->GetByName(permission_name);
+        if (permission)
+          apis.insert(permission->id());
+      }
+    }
+  }
+
+  // Retrieve the explicit host permissions.
+  URLPatternSet explicit_hosts;
+  ReadExtensionPrefURLPatternSet(
+      extension_id, JoinPrefs(pref_key, kPrefExplicitHosts),
+      &explicit_hosts, Extension::kValidHostPermissionSchemes);
+
+  // Retrieve the scriptable host permissions.
+  URLPatternSet scriptable_hosts;
+  ReadExtensionPrefURLPatternSet(
+      extension_id, JoinPrefs(pref_key, kPrefScriptableHosts),
+      &scriptable_hosts, UserScript::kValidUserScriptSchemes);
+
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+
+void ExtensionPrefs::SetExtensionPrefPermissionSet(
+    const std::string& extension_id,
+    const std::string& pref_key,
+    const ExtensionPermissionSet* new_value) {
+  // Set the API permissions.
+  ListValue* api_values = new ListValue();
+  ExtensionAPIPermissionSet apis = new_value->apis();
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
+  for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
+       i != apis.end(); ++i) {
+    ExtensionAPIPermission* perm = info->GetByID(*i);
+    if (perm)
+      api_values->Append(Value::CreateStringValue(perm->name()));
+  }
+  UpdateExtensionPref(extension_id, api_pref, api_values);
+
+  // Set the explicit host permissions.
+  if (!new_value->explicit_hosts().is_empty()) {
+    SetExtensionPrefURLPatternSet(extension_id,
+                                  JoinPrefs(pref_key, kPrefExplicitHosts),
+                                  new_value->explicit_hosts());
+  }
+
+  // Set the scriptable host permissions.
+  if (!new_value->scriptable_hosts().is_empty()) {
+    SetExtensionPrefURLPatternSet(extension_id,
+                                  JoinPrefs(pref_key, kPrefScriptableHosts),
+                                  new_value->scriptable_hosts());
+  }
+}
+
 void ExtensionPrefs::SavePrefs() {
   prefs_->ScheduleSavePersistentPrefs();
 }
@@ -638,7 +715,9 @@ void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
       ListValue* apis = NULL;
       ListValue* new_apis = NULL;
 
-      if (ext->GetList(kPrefGrantedAPIs, &apis))
+      std::string granted_apis =
+          JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
+      if (ext->GetList(kPrefOldGrantedAPIs, &apis))
         new_apis = apis->DeepCopy();
       else
         new_apis = new ListValue();
@@ -646,7 +725,7 @@ void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
       std::string plugin_name = info->GetByID(
           ExtensionAPIPermission::kPlugin)->name();
       new_apis->Append(Value::CreateStringValue(plugin_name));
-      UpdateExtensionPref(*ext_id, kPrefGrantedAPIs, new_apis);
+      UpdateExtensionPref(*ext_id, granted_apis, new_apis);
     }
 
     // The granted permissions originally only held the effective hosts,
@@ -656,9 +735,11 @@ void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
     // new effective hosts will be the same, so we move them to explicit
     // host permissions.
     ListValue* hosts;
+    std::string explicit_hosts =
+        JoinPrefs(kPrefGrantedPermissions, kPrefExplicitHosts);
     if (ext->GetList(kPrefOldGrantedHosts, &hosts)) {
       UpdateExtensionPref(
-          *ext_id, kPrefGrantedExplicitHosts, hosts->DeepCopy());
+          *ext_id, explicit_hosts, hosts->DeepCopy());
 
       // We can get rid of the old one by setting it to an empty list.
       UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new ListValue());
@@ -669,39 +750,7 @@ void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
 ExtensionPermissionSet* ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
-
-  const DictionaryValue* ext = GetExtensionPref(extension_id);
-  if (!ext)
-    return NULL;
-
-  // Retrieve the API permissions.
-  ExtensionAPIPermissionSet apis;
-  const ListValue* api_values = NULL;
-  if (ReadExtensionPrefList(extension_id, kPrefGrantedAPIs, &api_values)) {
-    ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
-    for (size_t i = 0; i < api_values->GetSize(); ++i) {
-      std::string permission_name;
-      if (api_values->GetString(i, &permission_name)) {
-        ExtensionAPIPermission *permission = info->GetByName(permission_name);
-        if (permission)
-          apis.insert(permission->id());
-      }
-    }
-  }
-
-  // Retrieve the explicit host permissions.
-  URLPatternSet explicit_hosts;
-  ReadExtensionPrefURLPatternSet(
-      extension_id, kPrefGrantedExplicitHosts,
-      &explicit_hosts, Extension::kValidHostPermissionSchemes);
-
-  // Retrieve the scriptable host permissions.
-  URLPatternSet scriptable_hosts;
-  ReadExtensionPrefURLPatternSet(
-      extension_id, kPrefGrantedScriptableHosts,
-      &scriptable_hosts, UserScript::kValidUserScriptSchemes);
-
-  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+  return ReadExtensionPrefPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
@@ -709,40 +758,30 @@ void ExtensionPrefs::AddGrantedPermissions(
     const ExtensionPermissionSet* permissions) {
   CHECK(Extension::IdIsValid(extension_id));
 
-  scoped_ptr<ExtensionPermissionSet> granted_permissions(
+  scoped_refptr<ExtensionPermissionSet> granted_permissions(
       GetGrantedPermissions(extension_id));
 
   // The new granted permissions are the union of the already granted
   // permissions and the newly granted permissions.
-  scoped_ptr<ExtensionPermissionSet> new_perms(
+  scoped_refptr<ExtensionPermissionSet> new_perms(
       ExtensionPermissionSet::CreateUnion(
           permissions, granted_permissions.get()));
 
-  // Set the API permissions.
-  ListValue* api_values = new ListValue();
-  ExtensionAPIPermissionSet apis = new_perms->apis();
-  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
-  for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
-       i != apis.end(); ++i) {
-    ExtensionAPIPermission* perm = info->GetByID(*i);
-    if (perm)
-      api_values->Append(Value::CreateStringValue(perm->name()));
-  }
-  UpdateExtensionPref(extension_id, kPrefGrantedAPIs, api_values);
+  SetExtensionPrefPermissionSet(
+      extension_id, kPrefGrantedPermissions, new_perms.get());
+}
 
-  // Set the explicit host permissions.
-  if (!new_perms->explicit_hosts().is_empty()) {
-    SetExtensionPrefURLPatternSet(extension_id,
-                                  kPrefGrantedExplicitHosts,
-                                  new_perms->explicit_hosts());
-  }
+ExtensionPermissionSet* ExtensionPrefs::GetActivePermissions(
+    const std::string& extension_id) {
+  CHECK(Extension::IdIsValid(extension_id));
+  return ReadExtensionPrefPermissionSet(extension_id, kPrefActivePermissions);
+}
 
-  // Set the scriptable host permissions.
-  if (!new_perms->scriptable_hosts().is_empty()) {
-    SetExtensionPrefURLPatternSet(extension_id,
-                                  kPrefGrantedScriptableHosts,
-                                  new_perms->scriptable_hosts());
-  }
+void ExtensionPrefs::SetActivePermissions(
+    const std::string& extension_id,
+    const ExtensionPermissionSet* permissions) {
+  SetExtensionPrefPermissionSet(
+      extension_id, kPrefActivePermissions, permissions);
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
diff --git a/chrome/browser/extensions/extension_prefs.h b/chrome/browser/extensions/extension_prefs.h
index 6b5ffd4..92f8672 100644
--- a/chrome/browser/extensions/extension_prefs.h
+++ b/chrome/browser/extensions/extension_prefs.h
@@ -187,6 +187,16 @@ class ExtensionPrefs : public ExtensionContentSettingsStore::Observer {
   void AddGrantedPermissions(const std::string& extension_id,
                              const ExtensionPermissionSet* permissions);
 
+  // Gets the active permission set for the specified extension. This may
+  // differ from the permissions in the manifest due to the optional
+  // permissions API. This passes ownership of the set to the caller.
+  ExtensionPermissionSet* GetActivePermissions(
+      const std::string& extension_id);
+
+  // Sets the active |permissions| for the extension with |extension_id|.
+  void SetActivePermissions(const std::string& extension_id,
+                            const ExtensionPermissionSet* permissions);
+
   // Returns true if the user enabled this extension to be loaded in incognito
   // mode.
   bool IsIncognitoEnabled(const std::string& extension_id);
@@ -409,6 +419,18 @@ class ExtensionPrefs : public ExtensionContentSettingsStore::Observer {
                                      const std::string& pref_key,
                                      const URLPatternSet& new_value);
 
+  // Interprets |pref_key| in |extension_id|'s preferences as an
+  // ExtensionPermissionSet, and passes ownership of the set to the caller.
+  ExtensionPermissionSet* ReadExtensionPrefPermissionSet(
+      const std::string& extension_id,
+      const std::string& pref_key);
+
+  // Converts the |new_value| to its value and sets the |pref_key| pref
+  // belonging to |extension_id|.
+  void SetExtensionPrefPermissionSet(const std::string& extension_id,
+                                     const std::string& pref_key,
+                                     const ExtensionPermissionSet* new_value);
+
   // Returns a dictionary for extension |id|'s prefs or NULL if it doesn't
   // exist.
   const base::DictionaryValue* GetExtensionPref(const std::string& id) const;
diff --git a/chrome/browser/extensions/extension_prefs_unittest.cc b/chrome/browser/extensions/extension_prefs_unittest.cc
index f582077..2ed6588 100644
--- a/chrome/browser/extensions/extension_prefs_unittest.cc
+++ b/chrome/browser/extensions/extension_prefs_unittest.cc
@@ -219,32 +219,32 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
 
     ExtensionAPIPermissionSet empty_set;
     URLPatternSet empty_extent;
-    scoped_ptr<ExtensionPermissionSet> permissions;
-    scoped_ptr<ExtensionPermissionSet> granted_permissions;
+    scoped_refptr<ExtensionPermissionSet> permissions;
+    scoped_refptr<ExtensionPermissionSet> granted_permissions;
 
     // Make sure both granted api and host permissions start empty.
-    granted_permissions.reset(
-        prefs()->GetGrantedPermissions(extension_id_));
+    granted_permissions =
+        prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(granted_permissions->IsEmpty());
 
-    permissions.reset(new ExtensionPermissionSet(
-        api_perm_set1_, empty_extent, empty_extent));
+    permissions = new ExtensionPermissionSet(
+        api_perm_set1_, empty_extent, empty_extent);
 
     // Add part of the api permissions.
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
-    granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
+    granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(granted_permissions.get());
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
     EXPECT_TRUE(granted_permissions->effective_hosts().is_empty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
-    granted_permissions.reset();
+    granted_permissions = NULL;
 
     // Add part of the explicit host permissions.
-    permissions.reset(new ExtensionPermissionSet(
-        empty_set, ehost_perm_set1_, empty_extent));
+    permissions = new ExtensionPermissionSet(
+        empty_set, ehost_perm_set1_, empty_extent);
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
-    granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
+    granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
@@ -254,10 +254,10 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
               granted_permissions->effective_hosts());
 
     // Add part of the scriptable host permissions.
-    permissions.reset(new ExtensionPermissionSet(
-        empty_set, empty_extent, shost_perm_set1_));
+    permissions = new ExtensionPermissionSet(
+        empty_set, empty_extent, shost_perm_set1_);
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
-    granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
+    granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_FALSE(granted_permissions->HasEffectiveFullAccess());
     EXPECT_EQ(expected_apis, granted_permissions->apis());
@@ -271,15 +271,15 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
     EXPECT_EQ(effective_permissions_, granted_permissions->effective_hosts());
 
     // Add the rest of both the permissions.
-    permissions.reset(new ExtensionPermissionSet(
-       api_perm_set2_, ehost_perm_set2_, shost_perm_set2_));
+    permissions = new ExtensionPermissionSet(
+       api_perm_set2_, ehost_perm_set2_, shost_perm_set2_);
 
     std::set_union(expected_apis.begin(), expected_apis.end(),
                    api_perm_set2_.begin(), api_perm_set2_.end(),
                    std::inserter(api_permissions_, api_permissions_.begin()));
 
     prefs()->AddGrantedPermissions(extension_id_, permissions.get());
-    granted_permissions.reset(prefs()->GetGrantedPermissions(extension_id_));
+    granted_permissions = prefs()->GetGrantedPermissions(extension_id_);
     EXPECT_TRUE(granted_permissions.get());
     EXPECT_FALSE(granted_permissions->IsEmpty());
     EXPECT_EQ(api_permissions_, granted_permissions->apis());
@@ -294,7 +294,7 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
   }
 
   virtual void Verify() {
-    scoped_ptr<ExtensionPermissionSet> permissions(
+    scoped_refptr<ExtensionPermissionSet> permissions(
         prefs()->GetGrantedPermissions(extension_id_));
     EXPECT_TRUE(permissions.get());
     EXPECT_FALSE(permissions->HasEffectiveFullAccess());
@@ -321,6 +321,54 @@ class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
 };
 TEST_F(ExtensionPrefsGrantedPermissions, GrantedPermissions) {}
 
+// Tests the SetActivePermissions / GetActivePermissions functions.
+class ExtensionPrefsActivePermissions : public ExtensionPrefsTest {
+ public:
+  virtual void Initialize() {
+    extension_id_ = prefs_.AddExtensionAndReturnId("test");
+
+    ExtensionAPIPermissionSet api_perms;
+    api_perms.insert(ExtensionAPIPermission::kTab);
+    api_perms.insert(ExtensionAPIPermission::kBookmark);
+    api_perms.insert(ExtensionAPIPermission::kHistory);
+
+    URLPatternSet ehosts;
+    AddPattern(&ehosts, "http://*.google.com/*");
+    AddPattern(&ehosts, "http://example.com/*");
+    AddPattern(&ehosts, "chrome://favicon/*");
+
+    URLPatternSet shosts;
+    AddPattern(&shosts, "https://*.google.com/*");
+    AddPattern(&shosts, "http://reddit.com/r/test/*");
+
+    active_perms_ = new ExtensionPermissionSet(api_perms, ehosts, shosts);
+
+    // Make sure the active permissions start empty.
+    scoped_refptr<ExtensionPermissionSet> active(
+        prefs()->GetActivePermissions(extension_id_));
+    EXPECT_TRUE(active->IsEmpty());
+
+    // Set the active permissions.
+    prefs()->SetActivePermissions(extension_id_, active_perms_.get());
+    active = prefs()->GetActivePermissions(extension_id_);
+    EXPECT_EQ(active_perms_->apis(), active->apis());
+    EXPECT_EQ(active_perms_->explicit_hosts(), active->explicit_hosts());
+    EXPECT_EQ(active_perms_->scriptable_hosts(), active->scriptable_hosts());
+    EXPECT_EQ(*active_perms_, *active);
+  }
+
+  virtual void Verify() {
+    scoped_refptr<ExtensionPermissionSet> permissions(
+        prefs()->GetActivePermissions(extension_id_));
+    EXPECT_EQ(*active_perms_, *permissions);
+  }
+
+ private:
+  std::string extension_id_;
+  scoped_refptr<ExtensionPermissionSet> active_perms_;
+};
+TEST_F(ExtensionPrefsActivePermissions, SetAndGetActivePermissions) {}
+
 // Tests the GetVersionString function.
 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
  public:
diff --git a/chrome/browser/extensions/extension_service.cc b/chrome/browser/extensions/extension_service.cc
index 5ff972e..72667a1 100644
--- a/chrome/browser/extensions/extension_service.cc
+++ b/chrome/browser/extensions/extension_service.cc
@@ -552,6 +552,7 @@ ExtensionService::ExtensionService(Profile* profile,
       show_extensions_prompts_(true),
       ready_(false),
       toolbar_model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      permissions_manager_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       apps_promo_(profile->GetPrefs()),
       event_routers_initialized_(false) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ -974,11 +975,13 @@ void ExtensionService::DisableExtension(const std::string& extension_id) {
 void ExtensionService::GrantPermissions(const Extension* extension) {
   CHECK(extension);
 
-  // We only maintain the granted permissions prefs for INTERNAL extensions.
-  CHECK_EQ(Extension::INTERNAL, extension->location());
+  // 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->permission_set());
+                                          extension->GetActivePermissions());
 }
 
 void ExtensionService::GrantPermissionsAndEnableExtension(
@@ -991,6 +994,13 @@ void ExtensionService::GrantPermissionsAndEnableExtension(
   EnableExtension(extension->id());
 }
 
+void ExtensionService::UpdateActivePermissions(
+    const Extension* extension,
+    const ExtensionPermissionSet* permissions) {
+  extension_prefs()->SetActivePermissions(extension->id(), permissions);
+  extension->SetActivePermissions(permissions);
+}
+
 void ExtensionService::LoadExtension(const FilePath& extension_path) {
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(backend_.get(),
@@ -1356,7 +1366,8 @@ void ExtensionService::NotifyExtensionLoaded(const Extension* extension) {
     if (host->profile()->GetOriginalProfile() ==
         profile_->GetOriginalProfile()) {
       host->Send(
-          new ExtensionMsg_Loaded(ExtensionMsg_Loaded_Params(extension)));
+          new ExtensionMsg_Loaded(ExtensionMsg_Loaded_Params(
+              extension, extension->GetActivePermissions())));
     }
   }
 
@@ -1964,7 +1975,7 @@ void ExtensionService::AddExtension(const Extension* extension) {
 
   // Check if the extension's privileges have changed and disable the
   // extension if necessary.
-  DisableIfPrivilegeIncrease(extension);
+  InitializePermissions(extension);
 
   bool disabled = Extension::UserMayDisable(extension->location()) &&
       extension_prefs_->GetExtensionState(extension->id()) ==
@@ -1985,7 +1996,35 @@ void ExtensionService::AddExtension(const Extension* extension) {
   NotifyExtensionLoaded(extension);
 }
 
-void ExtensionService::DisableIfPrivilegeIncrease(const Extension* extension) {
+void ExtensionService::InitializePermissions(const Extension* extension) {
+  // If the extension has used the optional permissions API, it will have a
+  // custom set of active permissions defined in the extension prefs. Here,
+  // we update the extension's active permissions based on the prefs.
+  scoped_refptr<ExtensionPermissionSet> active_permissions =
+      extension_prefs()->GetActivePermissions(extension->id());
+
+  if (active_permissions.get()) {
+    // We restrict the active permissions to be within the bounds defined in the
+    // extension's manifest.
+    //  a) active permissions must be a subset of optional + default permissions
+    //  b) active permissions must contains all default permissions
+    scoped_refptr<ExtensionPermissionSet> total_permissions =
+        ExtensionPermissionSet::CreateUnion(
+            extension->required_permission_set(),
+            extension->optional_permission_set());
+
+    // 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);
+  }
+
   // 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
@@ -2012,13 +2051,13 @@ void ExtensionService::DisableIfPrivilegeIncrease(const Extension* extension) {
   bool is_extension_upgrade = old != NULL;
   bool is_privilege_increase = false;
 
-  // We only record the granted permissions for INTERNAL extensions, since
-  // they can't silently increase privileges.
-  if (extension->location() == Extension::INTERNAL) {
+  // We only need to compare the granted permissions to the current permissions
+  // if the extension is not allowed to silently increase its permissions.
+  if (!extension->CanSilentlyIncreasePermissions()) {
     // Add all the recognized permissions if the granted permissions list
     // hasn't been initialized yet.
-    scoped_ptr<ExtensionPermissionSet> granted_permissions(
-        extension_prefs_->GetGrantedPermissions(extension->id()));
+    scoped_refptr<ExtensionPermissionSet> granted_permissions =
+        extension_prefs_->GetGrantedPermissions(extension->id());
     CHECK(granted_permissions.get());
 
     // Here, we check if an extension's privileges have increased in a manner
@@ -2026,7 +2065,8 @@ void ExtensionService::DisableIfPrivilegeIncrease(const Extension* extension) {
     // upgraded and recognized additional privileges, or an extension upgrades
     // to a version that requires additional privileges.
     is_privilege_increase =
-        granted_permissions->HasLessPrivilegesThan(extension->permission_set());
+        granted_permissions->HasLessPrivilegesThan(
+            extension->GetActivePermissions());
   }
 
   if (is_extension_upgrade) {
@@ -2378,7 +2418,8 @@ void ExtensionService::Observe(int type,
       // Loaded extensions.
       for (size_t i = 0; i < extensions_.size(); ++i) {
         process->Send(new ExtensionMsg_Loaded(
-            ExtensionMsg_Loaded_Params(extensions_[i])));
+            ExtensionMsg_Loaded_Params(
+                extensions_[i], extensions_[i]->GetActivePermissions())));
       }
       break;
     }
diff --git a/chrome/browser/extensions/extension_service.h b/chrome/browser/extensions/extension_service.h
index 4c74f0a..901726f 100644
--- a/chrome/browser/extensions/extension_service.h
+++ b/chrome/browser/extensions/extension_service.h
@@ -26,6 +26,7 @@
 #include "chrome/browser/extensions/extension_icon_manager.h"
 #include "chrome/browser/extensions/extension_menu_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
+#include "chrome/browser/extensions/extension_permissions_api.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
@@ -320,6 +321,10 @@ class ExtensionService
   // extension.
   void GrantPermissionsAndEnableExtension(const Extension* extension);
 
+  // Sets the |extension|'s active permissions to |permissions|.
+  void UpdateActivePermissions(const Extension* extension,
+                               const ExtensionPermissionSet* permissions);
+
   // Loads the extension from the directory |extension_path|.
   void LoadExtension(const FilePath& extension_path);
 
@@ -405,9 +410,9 @@ class ExtensionService
   void OnExtensionInstalled(
       const Extension* extension, bool from_webstore);
 
-  // Checks if the privileges requested by |extension| have increased, and if
-  // so, disables the extension and prompts the user to approve the change.
-  void DisableIfPrivilegeIncrease(const Extension* extension);
+  // Initializes the |extension|'s active permission set and disables the
+  // extension if the privilege level has increased (e.g., due to an upgrade).
+  void InitializePermissions(const Extension* extension);
 
   // Go through each extensions in pref, unload blacklisted extensions
   // and update the blacklist state in pref.
@@ -468,6 +473,10 @@ class ExtensionService
     return &app_notification_manager_;
   }
 
+  ExtensionPermissionsManager* permissions_manager() {
+    return &permissions_manager_;
+  }
+
   ExtensionBrowserEventRouter* browser_event_router() {
     return browser_event_router_.get();
   }
@@ -586,7 +595,6 @@ class ExtensionService
                                             bool include_disabled,
                                             bool include_terminated) const;
 
-
   // Adds the given extension to the list of terminated extensions if
   // it is not already there and unloads it.
   void TrackTerminatedExtension(const Extension* extension);
@@ -708,6 +716,9 @@ class ExtensionService
   // Keeps track of app notifications.
   AppNotificationManager app_notification_manager_;
 
+  // Keeps track of extension permissions.
+  ExtensionPermissionsManager permissions_manager_;
+
   // Keeps track of favicon-sized omnibox icons for extensions.
   ExtensionIconManager omnibox_icon_manager_;
   ExtensionIconManager omnibox_popup_icon_manager_;
diff --git a/chrome/browser/extensions/extension_service_unittest.cc b/chrome/browser/extensions/extension_service_unittest.cc
index bad22a1..c1a18d1 100644
--- a/chrome/browser/extensions/extension_service_unittest.cc
+++ b/chrome/browser/extensions/extension_service_unittest.cc
@@ -1023,7 +1023,8 @@ TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
   expected_patterns.ClearPatterns();
   AddPattern(&expected_patterns, "http://*.google.com/*");
   AddPattern(&expected_patterns, "https://*.google.com/*");
-  EXPECT_EQ(expected_patterns, extension->permission_set()->explicit_hosts());
+  EXPECT_EQ(expected_patterns,
+            extension->GetActivePermissions()->explicit_hosts());
 
   EXPECT_EQ(std::string(good1), loaded_[1]->id());
   EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
@@ -1364,7 +1365,7 @@ TEST_F(ExtensionServiceTest, GrantedPermissions) {
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
-  scoped_ptr<ExtensionPermissionSet> known_perms(
+  scoped_refptr<ExtensionPermissionSet> known_perms(
       prefs->GetGrantedPermissions(permissions_crx));
   EXPECT_FALSE(known_perms.get());
 
@@ -1383,7 +1384,7 @@ TEST_F(ExtensionServiceTest, GrantedPermissions) {
   AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
   AddPattern(&expected_host_perms, "http://www.example.com/*");
 
-  known_perms.reset(prefs->GetGrantedPermissions(extension_id));
+  known_perms = prefs->GetGrantedPermissions(extension_id);
   EXPECT_TRUE(known_perms.get());
   EXPECT_FALSE(known_perms->IsEmpty());
   EXPECT_EQ(expected_api_perms, known_perms->apis());
@@ -1412,7 +1413,7 @@ TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   std::string extension_id = extension->id();
   ExtensionPrefs* prefs = service_->extension_prefs();
 
-  scoped_ptr<ExtensionPermissionSet> permissions(
+  scoped_refptr<ExtensionPermissionSet> permissions(
       prefs->GetGrantedPermissions(extension_id));
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
@@ -1477,7 +1478,7 @@ TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
   ASSERT_TRUE(service_->IsExtensionEnabled(extension_id));
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
-  scoped_ptr<ExtensionPermissionSet> current_perms(
+  scoped_refptr<ExtensionPermissionSet> current_perms(
       prefs->GetGrantedPermissions(extension_id));
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
@@ -1490,7 +1491,7 @@ TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
   // updating the browser to a version which recognizes additional host
   // permissions).
   host_permissions.clear();
-  current_perms.reset();
+  current_perms = NULL;
 
   host_permissions.insert("http://*.google.com/*");
   host_permissions.insert("https://*.google.com/*");
@@ -1519,7 +1520,7 @@ TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
   ASSERT_TRUE(service_->IsExtensionEnabled(extension_id));
   ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
 
-  current_perms.reset(prefs->GetGrantedPermissions(extension_id));
+  current_perms = prefs->GetGrantedPermissions(extension_id);
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
diff --git a/chrome/browser/extensions/permissions_apitest.cc b/chrome/browser/extensions/permissions_apitest.cc
index e298a093..def0595 100644
--- a/chrome/browser/extensions/permissions_apitest.cc
+++ b/chrome/browser/extensions/permissions_apitest.cc
@@ -1,9 +1,14 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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_apitest.h"
+#include "chrome/browser/extensions/extension_prefs.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension_permission_set.h"
 
 class ExperimentalApiTest : public ExtensionApiTest {
 public:
@@ -47,3 +52,35 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, FaviconPermission) {
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, AlwaysAllowed) {
   ASSERT_TRUE(RunExtensionTest("permissions/always_allowed")) << message_;
 }
+
+// Tests that the optional permissions API works correctly.
+IN_PROC_BROWSER_TEST_F(ExperimentalApiTest, OptionalPermissionsGranted) {
+  // Mark all the tested APIs as granted to bypass the confirmation UI.
+  ExtensionAPIPermissionSet apis;
+  apis.insert(ExtensionAPIPermission::kTab);
+  apis.insert(ExtensionAPIPermission::kManagement);
+  apis.insert(ExtensionAPIPermission::kPermissions);
+  scoped_refptr<ExtensionPermissionSet> granted_permissions =
+      new ExtensionPermissionSet(apis, URLPatternSet(), URLPatternSet());
+
+  ExtensionPrefs* prefs =
+      browser()->profile()->GetExtensionService()->extension_prefs();
+  prefs->AddGrantedPermissions("kjmkgkdkpedkejedfhmfcenooemhbpbo",
+                               granted_permissions);
+
+  EXPECT_TRUE(RunExtensionTest("permissions/optional")) << message_;
+}
+
+// Tests that the optional permissions API works correctly.
+IN_PROC_BROWSER_TEST_F(ExperimentalApiTest, OptionalPermissionsAutoConfirm) {
+  // Rather than setting the granted permissions, set the UI autoconfirm flag
+  // and run the same tests.
+  RequestPermissionsFunction::SetAutoConfirmForTests(true);
+  EXPECT_TRUE(RunExtensionTest("permissions/optional")) << message_;
+}
+
+// Test that denying the optional permissions confirmation dialog works.
+IN_PROC_BROWSER_TEST_F(ExperimentalApiTest, OptionalPermissionsDeny) {
+  RequestPermissionsFunction::SetAutoConfirmForTests(false);
+  EXPECT_TRUE(RunExtensionTest("permissions/optional_deny")) << message_;
+}
diff --git a/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.h b/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.h
index 8c7818d..2617a53 100644
--- a/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.h
+++ b/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.h
@@ -37,6 +37,7 @@ class Profile;
   scoped_nsobject<NSString> title_;
   scoped_nsobject<NSString> warnings_;
   scoped_nsobject<NSString> button_;
+  scoped_nsobject<NSString> cancel_button_;
   scoped_nsobject<NSString> subtitle_;
   SkBitmap icon_;
 }
diff --git a/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.mm b/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.mm
index 1c8306a..0e79076f 100644
--- a/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.mm
+++ b/chrome/browser/ui/cocoa/extensions/extension_install_dialog_controller.mm
@@ -92,6 +92,9 @@ void OffsetControlVertically(NSControl* control, CGFloat amount) {
           retain]);
     button_.reset([l10n_util::GetNSString(ExtensionInstallUI::kButtonIds[type])
                    retain]);
+    int cancel_id = ExtensionInstallUI::kAbortButtonIds[type];
+    cancel_button_.reset([l10n_util::GetNSString(
+        cancel_id > 0 ? cancel_id : IDS_CANCEL) retain]);
 
     // We display the warnings as a simple text string, separated by newlines.
     if (!warnings.empty()) {
@@ -132,6 +135,7 @@ void OffsetControlVertically(NSControl* control, CGFloat amount) {
   [titleField_ setStringValue:title_.get()];
   [subtitleField_ setStringValue:subtitle_.get()];
   [okButton_ setTitle:button_.get()];
+  [cancelButton_ setTitle:cancel_button_.get()];
 
   NSImage* image = gfx::SkBitmapToNSImage(icon_);
   [iconView_ setImage:image];
diff --git a/chrome/browser/ui/gtk/extensions/extension_install_dialog_gtk.cc b/chrome/browser/ui/gtk/extensions/extension_install_dialog_gtk.cc
index cd2e99a..a49bc0a 100644
--- a/chrome/browser/ui/gtk/extensions/extension_install_dialog_gtk.cc
+++ b/chrome/browser/ui/gtk/extensions/extension_install_dialog_gtk.cc
@@ -62,8 +62,11 @@ void ShowInstallDialog(GtkWindow* parent,
       parent,
       GTK_DIALOG_MODAL,
       NULL);
-  GtkWidget* close_button = gtk_dialog_add_button(GTK_DIALOG(dialog),
-      GTK_STOCK_CANCEL, GTK_RESPONSE_CLOSE);
+  int cancel = ExtensionInstallUI::kAbortButtonIds[type];
+  GtkWidget* close_button = gtk_dialog_add_button(
+      GTK_DIALOG(dialog),
+      cancel > 0 ? l10n_util::GetStringUTF8(cancel).c_str(): GTK_STOCK_CANCEL,
+      GTK_RESPONSE_CLOSE);
   gtk_dialog_add_button(
       GTK_DIALOG(dialog),
       l10n_util::GetStringUTF8(ExtensionInstallUI::kButtonIds[type]).c_str(),
diff --git a/chrome/browser/ui/views/extensions/extension_install_dialog_view.cc b/chrome/browser/ui/views/extensions/extension_install_dialog_view.cc
index 1bf6d8f..b5c8a1ee 100644
--- a/chrome/browser/ui/views/extensions/extension_install_dialog_view.cc
+++ b/chrome/browser/ui/views/extensions/extension_install_dialog_view.cc
@@ -275,8 +275,10 @@ std::wstring ExtensionInstallDialogView::GetDialogButtonLabel(
     case MessageBoxFlags::DIALOGBUTTON_OK:
       return UTF16ToWide(
           l10n_util::GetStringUTF16(ExtensionInstallUI::kButtonIds[type_]));
-    case MessageBoxFlags::DIALOGBUTTON_CANCEL:
-      return UTF16ToWide(l10n_util::GetStringUTF16(IDS_CANCEL));
+    case MessageBoxFlags::DIALOGBUTTON_CANCEL: {
+        int id = ExtensionInstallUI::kAbortButtonIds[type_];
+        return UTF16ToWide(l10n_util::GetStringUTF16(id > 0 ? id : IDS_CANCEL));
+      }
     default:
       NOTREACHED();
       return std::wstring();
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 8b6d0a4..56ce107 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -1002,6 +1002,10 @@
         'browser/extensions/extension_page_actions_module.h',
         'browser/extensions/extension_page_actions_module_constants.cc',
         'browser/extensions/extension_page_actions_module_constants.h',
+        'browser/extensions/extension_permissions_api.cc',
+        'browser/extensions/extension_permissions_api.h',
+        'browser/extensions/extension_permissions_api_constants.cc',
+        'browser/extensions/extension_permissions_api_constants.h',
         'browser/extensions/extension_preference_api.cc',
         'browser/extensions/extension_preference_api.h',
         'browser/extensions/extension_preference_api_constants.cc',
diff --git a/chrome/common/chrome_notification_types.h b/chrome/common/chrome_notification_types.h
index 2472eb5..515373b 100644
--- a/chrome/common/chrome_notification_types.h
+++ b/chrome/common/chrome_notification_types.h
@@ -428,6 +428,10 @@ enum {
   // details are an Extension*, and the source is a Profile*.
   NOTIFICATION_EXTENSION_UPDATE_DISABLED,
 
+  // Sent when an extension's permissions change. The details are an
+  // UpdatedExtensionPermissionsInfo, and the source is a Profile.
+  NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED,
+
   // Sent when an extension is about to be installed so we can (in the case of
   // themes) alert the user with a loading dialog. The source is the download
   // manager and the details are the download url.
diff --git a/chrome/common/extensions/api/extension_api.json b/chrome/common/extensions/api/extension_api.json
index f3f8559..3e032aa 100644
--- a/chrome/common/extensions/api/extension_api.json
+++ b/chrome/common/extensions/api/extension_api.json
@@ -1060,6 +1060,143 @@
     ]
   },
   {
+    "namespace": "experimental.permissions",
+    "types": [
+      {
+        "id": "Permissions",
+        "type": "object",
+        "properties": {
+          "permissions": {
+            "type": "array",
+            "items": {"type": "string"},
+            "optional": true,
+            "description": "List of named permissions (does not include hosts or origins)."
+          }
+        }
+      }
+    ],
+    "events": [
+      {
+        "name": "onAdded",
+        "type": "function",
+        "unprivileged": true,
+        "description": "Fired when the extension acquires new permissions.",
+        "parameters": [
+          {
+            "$ref": "Permissions",
+            "name": "permissions",
+            "description": "The newly acquired permissions."
+          }
+        ]
+      },
+      {
+        "name": "onRemoved",
+        "type": "function",
+        "unprivileged": true,
+        "description": "Fired when access to permissions has been removed from the extension.",
+        "parameters": [
+          {
+            "$ref": "Permissions",
+            "name": "permissions",
+            "description": "The permissions that have been removed."
+          }
+        ]
+      }
+     ],
+    "functions": [
+      {
+        "name": "getAll",
+        "type": "function",
+        "unprivileged": true,
+        "description": "Gets the extension's current set of permissions.",
+        "parameters": [
+          {
+            "name": "callback",
+            "type": "function",
+            "parameters": [
+               {
+                "name": "permissions",
+                "$ref": "Permissions",
+                "description": "The extension's active permissions."
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "contains",
+        "type": "function",
+        "unprivileged": true,
+        "description": "Checks if the extension has the specified permissions.",
+        "parameters": [
+          {
+            "name": "permissions",
+            "$ref": "Permissions"
+          },
+          {
+            "name": "callback",
+            "type": "function",
+            "parameters": [
+              {
+                "name": "result",
+                "type": "boolean",
+                "description": "True if the extension has the specified permissions."
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "request",
+        "type": "function",
+        "unprivileged": true,
+        "description": "Requests access to the specified permissions. These permissions must be defined in the optional_permissions field of the manifest.",
+        "parameters": [
+          {
+            "name": "permissions",
+            "$ref": "Permissions"
+          },
+          {
+            "name": "callback",
+            "type": "function",
+            "optional": true,
+            "parameters": [
+              {
+                "name": "granted",
+                "type": "boolean",
+                "description": "True if the user granted the specified permissions."
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "name": "remove",
+        "type": "function",
+        "unprivileged": true,
+        "description": "Removes access to the specified permissions.",
+        "parameters": [
+          {
+            "name": "permissions",
+            "$ref": "Permissions"
+          },
+          {
+            "name": "callback",
+            "type": "function",
+            "optional": true,
+            "parameters": [
+              {
+                "name": "removed",
+                "type": "boolean",
+                "description": "True if the permissions were removed."
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
     "namespace": "tabs",
     "types": [
       {
diff --git a/chrome/common/extensions/docs/experimental.html b/chrome/common/extensions/docs/experimental.html
index 49aa374..8c62aec 100644
--- a/chrome/common/extensions/docs/experimental.html
+++ b/chrome/common/extensions/docs/experimental.html
@@ -328,6 +328,7 @@ on the following experimental APIs:
   <a href="experimental.devtools.panels.html">experimental.devtools.panels</a></li><li>
   <a href="experimental.devtools.resources.html">experimental.devtools.resources</a></li><li>
   <a href="experimental.infobars.html">experimental.infobars</a></li><li>
+  <a href="experimental.permissions.html">experimental.permissions</a></li><li>
   <a href="experimental.processes.html">experimental.processes</a></li><li>
   <a href="experimental.sidebar.html">experimental.sidebar</a></li><li>
   <a href="experimental.webNavigation.html">experimental.webNavigation</a></li><li>
diff --git a/chrome/common/extensions/docs/experimental.permissions.html b/chrome/common/extensions/docs/experimental.permissions.html
new file mode 100644
index 0000000..b167ee9
--- /dev/null
+++ b/chrome/common/extensions/docs/experimental.permissions.html
@@ -0,0 +1,1784 @@
+<!DOCTYPE html><!-- This page is a placeholder for generated extensions api doc. Note:
+    1) The <head> information in this page is significant, should be uniform
+       across api docs and should be edited only with knowledge of the
+       templating mechanism.
+    3) All <body>.innerHTML is genereated as an rendering step. If viewed in a
+       browser, it will be re-generated from the template, json schema and
+       authored overview content.
+    4) The <body>.innerHTML is also generated by an offline step so that this
+       page may easily be indexed by search engines.
+--><html xmlns="http://www.w3.org/1999/xhtml"><head>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <link href="css/ApiRefStyles.css" rel="stylesheet" type="text/css">
+    <link href="css/print.css" rel="stylesheet" type="text/css" media="print">
+    <script type="text/javascript" src="../../../third_party/jstemplate/jstemplate_compiled.js">
+    </script>
+    <script type="text/javascript" src="js/api_page_generator.js"></script>
+    <script type="text/javascript" src="js/bootstrap.js"></script>
+    <script type="text/javascript" src="js/sidebar.js"></script>
+  <title>chrome.experimental.permissions - Google Chrome Extensions - Google Code</title></head>
+  <body>  <div id="gc-container" class="labs">
+      <div id="devModeWarning">
+        You are viewing extension docs in chrome via the 'file:' scheme: are you expecting to see local changes when you refresh? You'll need run chrome with --allow-file-access-from-files.
+      </div>
+      <!-- SUBTEMPLATES: DO NOT MOVE FROM THIS LOCATION -->
+      <!-- In particular, sub-templates that recurse, must be used by allowing
+           jstemplate to make a copy of the template in this section which
+           are not operated on by way of the jsskip="true" -->
+      <div style="display:none">
+
+        <!-- VALUE -->
+        <div id="valueTemplate">
+          <dt>
+            <var>paramName</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional">optional</span>
+                    <span class="enum">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd>
+            Description of this parameter from the json schema.
+          </dd>
+          <dd>
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd>
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd>
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd>
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd>
+            <div></div>
+          </dd>
+
+        </div> <!-- /VALUE -->
+
+        <div id="functionParametersTemplate">
+          <h5>Parameters</h5>
+          <dl>
+            <div>
+              <div>
+              </div>
+            </div>
+          </dl>
+        </div>
+      </div> <!-- /SUBTEMPLATES -->
+
+  <a id="top"></a>
+    <div id="skipto">
+      <a href="#gc-pagecontent">Skip to page content</a>
+      <a href="#gc-toc">Skip to main navigation</a>
+    </div>
+    <!-- API HEADER -->
+    <table id="header" width="100%" cellspacing="0" border="0">
+      <tbody><tr>
+        <td valign="middle"><a href="http://code.google.com/"><img src="images/code_labs_logo.gif" height="43" width="161" alt="Google Code Labs" style="border:0; margin:0;"></a></td>
+        <td valign="middle" width="100%" style="padding-left:0.6em;">
+          <form action="http://www.google.com/cse" id="cse" style="margin-top:0.5em">
+            <div id="gsc-search-box">
+              <input type="hidden" name="cx" value="002967670403910741006:61_cvzfqtno">
+              <input type="hidden" name="ie" value="UTF-8">
+              <input type="text" name="q" value="" size="55">
+              <input class="gsc-search-button" type="submit" name="sa" value="Search">
+              <br>
+              <span class="greytext">e.g. "page action" or "tabs"</span>
+            </div>
+          </form>
+
+          <script type="text/javascript" src="http://www.google.com/jsapi"></script>
+          <script type="text/javascript">google.load("elements", "1", {packages: "transliteration"});</script>
+          <script type="text/javascript" src="http://www.google.com/coop/cse/t13n?form=cse&amp;t13n_langs=en"></script>
+          <script type="text/javascript" src="http://www.google.com/coop/cse/brand?form=cse&amp;lang=en"></script>
+        </td>
+      </tr>
+    </tbody></table>
+
+    <div id="codesiteContent" class="">
+
+      <a id="gc-topnav-anchor"></a>
+      <div id="gc-topnav">
+        <h1>Google Chrome Extensions (<a href="http://code.google.com/labs/">Labs</a>)</h1>
+        <ul id="home" class="gc-topnav-tabs">
+          <li id="home_link">
+            <a href="index.html" title="Google Chrome Extensions home page">Home</a>
+          </li>
+          <li id="docs_link">
+            <a href="docs.html" title="Official Google Chrome Extensions documentation">Docs</a>
+          </li>
+          <li id="faq_link">
+            <a href="faq.html" title="Answers to frequently asked questions about Google Chrome Extensions">FAQ</a>
+          </li>
+          <li id="samples_link">
+            <a href="samples.html" title="Sample extensions (with source code)">Samples</a>
+          </li>
+          <li id="group_link">
+            <a href="http://groups.google.com/a/chromium.org/group/chromium-extensions" title="Google Chrome Extensions developer forum">Group</a>
+          </li>
+        </ul>
+      </div> <!-- end gc-topnav -->
+
+    <div class="g-section g-tpl-170">
+      <!-- SIDENAV -->
+      <div class="g-unit g-first" id="gc-toc">
+        <ul>
+          <li><a href="getstarted.html">Getting Started</a></li>
+          <li><a href="overview.html">Overview</a></li>
+          <li><a href="whats_new.html">What's New?</a></li>
+          <li><h2><a href="devguide.html">Developer's Guide</a></h2>
+            <ul>
+              <li>Browser UI
+                <ul>
+                  <li><a href="browserAction.html">Browser Actions</a></li>
+                  <li><a href="contextMenus.html">Context Menus</a></li>
+                  <li><a href="notifications.html">Desktop Notifications</a></li>
+                  <li><a href="omnibox.html">Omnibox</a></li>
+                  <li><a href="options.html">Options Pages</a></li>
+                  <li><a href="override.html">Override Pages</a></li>
+                  <li><a href="pageAction.html">Page Actions</a></li>
+                </ul>
+              </li>
+              <li>Browser Interaction
+                <ul>
+                  <li><a href="bookmarks.html">Bookmarks</a></li>
+                  <li><a href="cookies.html">Cookies</a></li>
+                  <li><a href="events.html">Events</a></li>
+                  <li><a href="history.html">History</a></li>
+                  <li><a href="management.html">Management</a></li>
+                  <li><a href="tabs.html">Tabs</a></li>
+                  <li><a href="windows.html">Windows</a></li>
+                </ul>
+              </li>
+              <li>Implementation
+                <ul>
+                  <li><a href="a11y.html">Accessibility</a></li>
+                  <li><a href="background_pages.html">Background Pages</a></li>
+                  <li><a href="content_scripts.html">Content Scripts</a></li>
+                  <li><a href="xhr.html">Cross-Origin XHR</a></li>
+                  <li><a href="idle.html">Idle</a></li>
+                  <li><a href="i18n.html">Internationalization</a></li>
+                  <li><a href="messaging.html">Message Passing</a></li>
+                  <li><a href="npapi.html">NPAPI Plugins</a></li>
+                </ul>
+              </li>
+              <li>Finishing
+                <ul>
+                  <li><a href="hosting.html">Hosting</a></li>
+                  <li><a href="external_extensions.html">Other Deployment Options</a></li>
+                </ul>
+              </li>
+            </ul>
+          </li>
+          <li><h2><a href="apps.html">Packaged Apps</a></h2></li>
+          <li><h2><a href="tutorials.html">Tutorials</a></h2>
+            <ul>
+              <li><a href="tut_debugging.html">Debugging</a></li>
+              <li><a href="tut_analytics.html">Google Analytics</a></li>
+              <li><a href="tut_oauth.html">OAuth</a></li>
+            </ul>
+          </li>
+          <li><h2>Reference</h2>
+            <ul>
+              <li>Formats
+                <ul>
+                  <li><a href="manifest.html">Manifest Files</a></li>
+                  <li><a href="match_patterns.html">Match Patterns</a></li>
+                </ul>
+              </li>
+              <li><a href="permission_warnings.html">Permission Warnings</a></li>
+              <li><a href="api_index.html">chrome.* APIs</a></li>
+              <li><a href="api_other.html">Other APIs</a></li>
+            </ul>
+          </li>
+          <li><h2><a href="samples.html">Samples</a></h2></li>
+          <div class="line"> </div>
+          <li><h2>More</h2>
+            <ul>
+              <li><a href="http://code.google.com/chrome/webstore/docs/index.html">Chrome Web Store</a></li>
+              <li><a href="http://code.google.com/chrome/apps/docs/developers_guide.html">Hosted Apps</a></li>
+              <li><a href="themes.html">Themes</a></li>
+            </ul>
+          </li>
+        </ul>
+      </div>
+      <script>
+        initToggles();
+      </script>
+
+    <div class="g-unit" id="gc-pagecontent">
+      <div id="pageTitle">
+        <h1 class="page_title">chrome.experimental.permissions</h1>
+      </div>
+        <!-- TABLE OF CONTENTS -->
+        <div id="toc">
+          <h2>Contents</h2>
+          <ol>
+            <li style="display: none; ">
+              <a>h2Name</a>
+              <ol>
+                <li>
+                  <a>h3Name</a>
+                </li>
+              </ol>
+            </li>
+              <li>
+                <a href="#apiReference">API reference: chrome.experimental.permissions</a>
+                <ol>
+                  <li style="display: none; ">
+                    <a href="#properties">Properties</a>
+                    <ol>
+                      <li>
+                        <a href="#property-anchor">propertyName</a>
+                      </li>
+                    </ol>
+                  </li>
+                  <li>
+                    <a href="#global-methods">Methods</a>
+                    <ol>
+                      <li>
+                        <a href="#method-contains">contains</a>
+                      </li><li>
+                        <a href="#method-getAll">getAll</a>
+                      </li><li>
+                        <a href="#method-remove">remove</a>
+                      </li><li>
+                        <a href="#method-request">request</a>
+                      </li>
+                    </ol>
+                  </li>
+                  <li>
+                    <a href="#global-events">Events</a>
+                    <ol>
+                      <li>
+                        <a href="#event-onAdded">onAdded</a>
+                      </li><li>
+                        <a href="#event-onRemoved">onRemoved</a>
+                      </li>
+                    </ol>
+                  </li>
+                  <li>
+                    <a href="#types">Types</a>
+                    <ol>
+                      <li>
+                        <a href="#type-Permissions">Permissions</a>
+                      </li>
+                    </ol>
+                  </li>
+                </ol>
+              </li>
+          </ol>
+        </div>
+        <!-- /TABLE OF CONTENTS -->
+
+        <!-- Standard content lead-in for experimental API pages -->
+        <p id="classSummary">
+          For information on how to use experimental APIs, see the <a href="experimental.html">chrome.experimental.* APIs</a> page.
+        </p>
+
+        <!-- STATIC CONTENT PLACEHOLDER -->
+        <div id="static"></div>
+
+        <!-- API PAGE -->
+        <div class="apiPage">
+        <a name="apiReference"></a>
+        <h2>API reference: chrome.experimental.permissions</h2>
+
+          <!-- PROPERTIES -->
+          <div class="apiGroup" style="display: none; ">
+            <a name="properties"></a>
+            <h3 id="properties">Properties</h3>
+
+            <div>
+              <a></a>
+              <h4>getLastError</h4>
+              <div class="summary">
+                <!-- Note: intentionally longer 80 columns -->
+                <span>chrome.extension</span><span>lastError</span>
+              </div>
+              <div>
+              </div>
+            </div>
+
+          </div> <!-- /apiGroup -->
+
+          <!-- METHODS -->
+          <div id="methodsTemplate" class="apiGroup">
+            <a name="global-methods"></a>
+            <h3>Methods</h3>
+
+            <!-- iterates over all functions -->
+            <div class="apiItem">
+              <a name="method-contains"></a> <!-- method-anchor -->
+              <h4>contains</h4>
+
+              <div class="summary"><span style="display: none; ">void</span>
+                  <!-- Note: intentionally longer 80 columns -->
+                  <span>chrome.experimental.permissions.contains</span>(<span class="null"><span style="display: none; ">, </span><span>Permissions</span>
+                      <var><span>permissions</span></var></span><span class="null"><span>, </span><span>function</span>
+                      <var><span>callback</span></var></span>)</div>
+
+              <div class="description">
+                <p class="todo" style="display: none; ">Undocumented.</p>
+                <p>Checks if the extension has the specified permissions.</p>
+
+                <!-- PARAMETERS -->
+                <h4>Parameters</h4>
+                <dl>
+                  <div>
+                    <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a href="experimental.permissions.html#type-Permissions">Permissions</a>
+                      </span>
+                      <span style="display: none; ">
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div><div>
+                    <div>
+          <dt>
+            <var>callback</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>function</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div>
+                </dl>
+
+                <!-- RETURNS -->
+                <h4 style="display: none; ">Returns</h4>
+                <dl>
+                  <div style="display: none; ">
+                    <div>
+                    </div>
+                  </div>
+                </dl>
+
+                <!-- CALLBACK -->
+                <div>
+                  <div>
+                  <h4>Callback function</h4>
+                  <p>
+                    The callback <em>parameter</em> should specify a function
+                    that looks like this:
+                  </p>
+                  <p style="display: none; ">
+                    If you specify the <em>callback</em> parameter, it should
+                    specify a function that looks like this:
+                  </p>
+
+                  <!-- Note: intentionally longer 80 columns -->
+                  <pre>function(<span>boolean result</span>) <span class="subdued">{...}</span>;</pre>
+                  <dl>
+                    <div>
+                      <div>
+          <dt>
+            <var>result</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>boolean</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>True if the extension has the specified permissions.</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                    </div>
+                  </dl>
+                  </div>
+                </div>
+
+                <!-- MIN_VERSION -->
+                <p style="display: none; ">
+                  This function was added in version <b><span></span></b>.
+                  If you require this function, the manifest key
+                  <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+                  can ensure that your extension won't be run in an earlier browser version.
+                </p>
+              </div> <!-- /description -->
+
+            </div><div class="apiItem">
+              <a name="method-getAll"></a> <!-- method-anchor -->
+              <h4>getAll</h4>
+
+              <div class="summary"><span style="display: none; ">void</span>
+                  <!-- Note: intentionally longer 80 columns -->
+                  <span>chrome.experimental.permissions.getAll</span>(<span class="null"><span style="display: none; ">, </span><span>function</span>
+                      <var><span>callback</span></var></span>)</div>
+
+              <div class="description">
+                <p class="todo" style="display: none; ">Undocumented.</p>
+                <p>Gets the extension's current set of permissions.</p>
+
+                <!-- PARAMETERS -->
+                <h4>Parameters</h4>
+                <dl>
+                  <div>
+                    <div>
+          <dt>
+            <var>callback</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>function</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div>
+                </dl>
+
+                <!-- RETURNS -->
+                <h4 style="display: none; ">Returns</h4>
+                <dl>
+                  <div style="display: none; ">
+                    <div>
+                    </div>
+                  </div>
+                </dl>
+
+                <!-- CALLBACK -->
+                <div>
+                  <div>
+                  <h4>Callback function</h4>
+                  <p>
+                    The callback <em>parameter</em> should specify a function
+                    that looks like this:
+                  </p>
+                  <p style="display: none; ">
+                    If you specify the <em>callback</em> parameter, it should
+                    specify a function that looks like this:
+                  </p>
+
+                  <!-- Note: intentionally longer 80 columns -->
+                  <pre>function(<span>Permissions permissions</span>) <span class="subdued">{...}</span>;</pre>
+                  <dl>
+                    <div>
+                      <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a href="experimental.permissions.html#type-Permissions">Permissions</a>
+                      </span>
+                      <span style="display: none; ">
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>The extension's active permissions.</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                    </div>
+                  </dl>
+                  </div>
+                </div>
+
+                <!-- MIN_VERSION -->
+                <p style="display: none; ">
+                  This function was added in version <b><span></span></b>.
+                  If you require this function, the manifest key
+                  <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+                  can ensure that your extension won't be run in an earlier browser version.
+                </p>
+              </div> <!-- /description -->
+
+            </div><div class="apiItem">
+              <a name="method-remove"></a> <!-- method-anchor -->
+              <h4>remove</h4>
+
+              <div class="summary"><span style="display: none; ">void</span>
+                  <!-- Note: intentionally longer 80 columns -->
+                  <span>chrome.experimental.permissions.remove</span>(<span class="null"><span style="display: none; ">, </span><span>Permissions</span>
+                      <var><span>permissions</span></var></span><span class="optional"><span>, </span><span>function</span>
+                      <var><span>callback</span></var></span>)</div>
+
+              <div class="description">
+                <p class="todo" style="display: none; ">Undocumented.</p>
+                <p>Removes access to the specified permissions.</p>
+
+                <!-- PARAMETERS -->
+                <h4>Parameters</h4>
+                <dl>
+                  <div>
+                    <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a href="experimental.permissions.html#type-Permissions">Permissions</a>
+                      </span>
+                      <span style="display: none; ">
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div><div>
+                    <div>
+          <dt>
+            <var>callback</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>function</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div>
+                </dl>
+
+                <!-- RETURNS -->
+                <h4 style="display: none; ">Returns</h4>
+                <dl>
+                  <div style="display: none; ">
+                    <div>
+                    </div>
+                  </div>
+                </dl>
+
+                <!-- CALLBACK -->
+                <div>
+                  <div>
+                  <h4>Callback function</h4>
+                  <p style="display: none; ">
+                    The callback <em>parameter</em> should specify a function
+                    that looks like this:
+                  </p>
+                  <p>
+                    If you specify the <em>callback</em> parameter, it should
+                    specify a function that looks like this:
+                  </p>
+
+                  <!-- Note: intentionally longer 80 columns -->
+                  <pre>function(<span>boolean removed</span>) <span class="subdued">{...}</span>;</pre>
+                  <dl>
+                    <div>
+                      <div>
+          <dt>
+            <var>removed</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>boolean</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>True if the permissions were removed.</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                    </div>
+                  </dl>
+                  </div>
+                </div>
+
+                <!-- MIN_VERSION -->
+                <p style="display: none; ">
+                  This function was added in version <b><span></span></b>.
+                  If you require this function, the manifest key
+                  <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+                  can ensure that your extension won't be run in an earlier browser version.
+                </p>
+              </div> <!-- /description -->
+
+            </div><div class="apiItem">
+              <a name="method-request"></a> <!-- method-anchor -->
+              <h4>request</h4>
+
+              <div class="summary"><span style="display: none; ">void</span>
+                  <!-- Note: intentionally longer 80 columns -->
+                  <span>chrome.experimental.permissions.request</span>(<span class="null"><span style="display: none; ">, </span><span>Permissions</span>
+                      <var><span>permissions</span></var></span><span class="optional"><span>, </span><span>function</span>
+                      <var><span>callback</span></var></span>)</div>
+
+              <div class="description">
+                <p class="todo" style="display: none; ">Undocumented.</p>
+                <p>Requests access to the specified permissions. These permissions must be defined in the optional_permissions field of the manifest.</p>
+
+                <!-- PARAMETERS -->
+                <h4>Parameters</h4>
+                <dl>
+                  <div>
+                    <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a href="experimental.permissions.html#type-Permissions">Permissions</a>
+                      </span>
+                      <span style="display: none; ">
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div><div>
+                    <div>
+          <dt>
+            <var>callback</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>function</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                  </div>
+                </dl>
+
+                <!-- RETURNS -->
+                <h4 style="display: none; ">Returns</h4>
+                <dl>
+                  <div style="display: none; ">
+                    <div>
+                    </div>
+                  </div>
+                </dl>
+
+                <!-- CALLBACK -->
+                <div>
+                  <div>
+                  <h4>Callback function</h4>
+                  <p style="display: none; ">
+                    The callback <em>parameter</em> should specify a function
+                    that looks like this:
+                  </p>
+                  <p>
+                    If you specify the <em>callback</em> parameter, it should
+                    specify a function that looks like this:
+                  </p>
+
+                  <!-- Note: intentionally longer 80 columns -->
+                  <pre>function(<span>boolean granted</span>) <span class="subdued">{...}</span>;</pre>
+                  <dl>
+                    <div>
+                      <div>
+          <dt>
+            <var>granted</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>boolean</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>True if the user granted the specified permissions.</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                    </div>
+                  </dl>
+                  </div>
+                </div>
+
+                <!-- MIN_VERSION -->
+                <p style="display: none; ">
+                  This function was added in version <b><span></span></b>.
+                  If you require this function, the manifest key
+                  <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+                  can ensure that your extension won't be run in an earlier browser version.
+                </p>
+              </div> <!-- /description -->
+
+            </div>  <!-- /apiItem -->
+
+          </div>  <!-- /apiGroup -->
+
+          <!-- EVENTS -->
+          <div id="eventsTemplate" class="apiGroup">
+            <a name="global-events"></a>
+            <h3>Events</h3>
+            <!-- iterates over all events -->
+            <div class="apiItem">
+              <a name="event-onAdded"></a>
+              <h4>onAdded</h4>
+
+              <div class="summary">
+                <!-- Note: intentionally longer 80 columns -->
+                <span class="subdued">chrome.experimental.permissions.</span><span>onAdded</span><span class="subdued">.addListener</span>(function(<span>Permissions permissions</span>) <span class="subdued">{...}</span><span></span>));
+              </div>
+
+              <div class="description">
+                <p class="todo" style="display: none; ">Undocumented.</p>
+                <p>Fired when the extension acquires new permissions.</p>
+
+                <!-- LISTENER PARAMETERS -->
+                <div>
+                  <h4>Listener parameters</h4>
+                  <dl>
+                    <div>
+                      <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a href="experimental.permissions.html#type-Permissions">Permissions</a>
+                      </span>
+                      <span style="display: none; ">
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>The newly acquired permissions.</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                    </div>
+                  </dl>
+                </div>
+
+                <!-- EXTRA PARAMETERS -->
+                <div style="display: none; ">
+                  <h4>Extra parameters to addListener</h4>
+                  <dl>
+                    <div>
+                      <div>
+                      </div>
+                    </div>
+                  </dl>
+                </div>
+
+                <!-- LISTENER RETURN VALUE -->
+                <h4 style="display: none; ">Listener returns</h4>
+                <dl>
+                  <div style="display: none; ">
+                    <div>
+                    </div>
+                  </div>
+                </dl>
+
+              </div> <!-- /description -->
+            </div><div class="apiItem">
+              <a name="event-onRemoved"></a>
+              <h4>onRemoved</h4>
+
+              <div class="summary">
+                <!-- Note: intentionally longer 80 columns -->
+                <span class="subdued">chrome.experimental.permissions.</span><span>onRemoved</span><span class="subdued">.addListener</span>(function(<span>Permissions permissions</span>) <span class="subdued">{...}</span><span></span>));
+              </div>
+
+              <div class="description">
+                <p class="todo" style="display: none; ">Undocumented.</p>
+                <p>Fired when access to permissions has been removed from the extension.</p>
+
+                <!-- LISTENER PARAMETERS -->
+                <div>
+                  <h4>Listener parameters</h4>
+                  <dl>
+                    <div>
+                      <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span>
+                        <a href="experimental.permissions.html#type-Permissions">Permissions</a>
+                      </span>
+                      <span style="display: none; ">
+                        <span>
+                          array of <span><span></span></span>
+                        </span>
+                        <span>paramType</span>
+                        <span></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>The permissions that have been removed.</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+                    </div>
+                  </dl>
+                </div>
+
+                <!-- EXTRA PARAMETERS -->
+                <div style="display: none; ">
+                  <h4>Extra parameters to addListener</h4>
+                  <dl>
+                    <div>
+                      <div>
+                      </div>
+                    </div>
+                  </dl>
+                </div>
+
+                <!-- LISTENER RETURN VALUE -->
+                <h4 style="display: none; ">Listener returns</h4>
+                <dl>
+                  <div style="display: none; ">
+                    <div>
+                    </div>
+                  </div>
+                </dl>
+
+              </div> <!-- /description -->
+            </div> <!-- /apiItem -->
+
+          </div> <!-- /apiGroup -->
+
+          <!-- TYPES -->
+          <div class="apiGroup">
+            <a name="types"></a>
+            <h3 id="types">Types</h3>
+
+            <!-- iterates over all types -->
+            <div class="apiItem">
+              <a name="type-Permissions"></a>
+              <h4>Permissions</h4>
+
+              <div>
+          <dt>
+            <var style="display: none; ">paramName</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional" style="display: none; ">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>object</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo">
+            Undocumented.
+          </dd>
+          <dd style="display: none; ">
+            Description of this parameter from the json schema.
+          </dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd>
+            <dl>
+              <div>
+                <div>
+          <dt>
+            <var>permissions</var>
+              <em>
+
+                <!-- TYPE -->
+                <div style="display:inline">
+                  (
+                    <span class="optional">optional</span>
+                    <span class="enum" style="display: none; ">enumerated</span>
+                    <span id="typeTemplate">
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span>
+                          array of <span><span>
+                      <span style="display: none; ">
+                        <a> Type</a>
+                      </span>
+                      <span>
+                        <span style="display: none; ">
+                          array of <span><span></span></span>
+                        </span>
+                        <span>string</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span></span>
+                        </span>
+                        <span style="display: none; ">paramType</span>
+                        <span style="display: none; "></span>
+                      </span>
+                    </span>
+                  )
+                </div>
+
+              </em>
+          </dt>
+          <dd class="todo" style="display: none; ">
+            Undocumented.
+          </dd>
+          <dd>List of named permissions (does not include hosts or origins).</dd>
+          <dd style="display: none; ">
+            This parameter was added in version
+            <b><span></span></b>.
+            You must omit this parameter in earlier versions,
+            and you may omit it in any version.  If you require this
+            parameter, the manifest key
+            <a href="manifest.html#minimum_chrome_version">minimum_chrome_version</a>
+            can ensure that your extension won't be run in an earlier browser version.
+          </dd>
+
+          <!-- OBJECT PROPERTIES -->
+          <dd style="display: none; ">
+            <dl>
+              <div>
+                <div>
+                </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+              </div>
+            </dl>
+          </dd>
+
+          <!-- OBJECT METHODS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- OBJECT EVENT FIELDS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+          <!-- FUNCTION PARAMETERS -->
+          <dd style="display: none; ">
+            <div></div>
+          </dd>
+
+        </div>
+
+            </div> <!-- /apiItem -->
+
+          </div> <!-- /apiGroup -->
+
+        </div> <!-- /apiPage -->
+      </div> <!-- /gc-pagecontent -->
+    </div> <!-- /g-section -->
+  </div> <!-- /codesiteContent -->
+    <div id="gc-footer" --="">
+      <div class="text">
+  <p>
+  Except as otherwise <a href="http://code.google.com/policies.html#restrictions">noted</a>,
+  the content of this page is licensed under the <a rel="license" href="http://creativecommons.org/licenses/by/3.0/">Creative Commons
+  Attribution 3.0 License</a>, and code samples are licensed under the
+  <a rel="license" href="http://code.google.com/google_bsd_license.html">BSD License</a>.
+  </p>
+  <p>
+  ©2011 Google
+  </p>
+
+<!-- begin analytics -->
+<script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
+<script src="http://www.google-analytics.com/ga.js" type="text/javascript"></script>
+
+<script type="text/javascript">
+  // chrome doc tracking
+  try {
+    var engdocs = _gat._getTracker("YT-10763712-2");
+    engdocs._trackPageview();
+  } catch(err) {}
+
+  // code.google.com site-wide tracking
+  try {
+    _uacct="UA-18071-1";
+    _uanchor=1;
+    _uff=0;
+    urchinTracker();
+  }
+  catch(e) {/* urchinTracker not available. */}
+</script>
+<!-- end analytics -->
+      </div>
+    </div> <!-- /gc-footer -->
+  </div> <!-- /gc-container -->
+</body></html>
diff --git a/chrome/common/extensions/docs/samples.json b/chrome/common/extensions/docs/samples.json
index 862059d..56dbf21 100644
--- a/chrome/common/extensions/docs/samples.json
+++ b/chrome/common/extensions/docs/samples.json
@@ -51,6 +51,12 @@
     "chrome.experimental.devtools.resources.onFinished": "experimental.devtools.resources.html#event-onFinished",
     "chrome.experimental.devtools.resources.onNavigation": "experimental.devtools.resources.html#event-onNavigation",
     "chrome.experimental.infobars.show": "experimental.infobars.html#method-show",
+    "chrome.experimental.permissions.contains": "experimental.permissions.html#method-contains",
+    "chrome.experimental.permissions.getAll": "experimental.permissions.html#method-getAll",
+    "chrome.experimental.permissions.onAdded": "experimental.permissions.html#event-onAdded",
+    "chrome.experimental.permissions.onRemoved": "experimental.permissions.html#event-onRemoved",
+    "chrome.experimental.permissions.remove": "experimental.permissions.html#method-remove",
+    "chrome.experimental.permissions.request": "experimental.permissions.html#method-request",
     "chrome.experimental.processes.getProcessIdForTab": "experimental.processes.html#method-getProcessIdForTab",
     "chrome.experimental.processes.onUpdated": "experimental.processes.html#event-onUpdated",
     "chrome.experimental.sidebar.collapse": "experimental.sidebar.html#method-collapse",
diff --git a/chrome/common/extensions/extension.cc b/chrome/common/extensions/extension.cc
index 111ed76..5488349 100644
--- a/chrome/common/extensions/extension.cc
+++ b/chrome/common/extensions/extension.cc
@@ -286,20 +286,6 @@ Extension::Location Extension::GetHigherPriorityLocation(
   return (loc1_rank > loc2_rank ? loc1 : loc2 );
 }
 
-ExtensionPermissionMessages Extension::GetPermissionMessages() const {
-  if (IsTrustedId(id_))
-    return ExtensionPermissionMessages();
-  else
-    return permission_set_->GetPermissionMessages();
-}
-
-std::vector<string16> Extension::GetPermissionMessageStrings() const {
-  if (IsTrustedId(id_))
-    return std::vector<string16>();
-  else
-    return permission_set_->GetWarningMessages();
-}
-
 void Extension::OverrideLaunchUrl(const GURL& override_url) {
   GURL new_url(override_url);
   if (!new_url.is_valid()) {
@@ -1202,6 +1188,7 @@ bool Extension::EnsureNotHybridApp(const DictionaryValue* manifest,
     if (!IsBaseCrxKey(*key) &&
         *key != keys::kApp &&
         *key != keys::kPermissions &&
+        *key != keys::kOptionalPermissions &&
         *key != keys::kOptionsPage &&
         *key != keys::kBackground) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
@@ -1385,13 +1372,16 @@ GURL Extension::GetBaseURLFromExtensionId(const std::string& extension_id) {
 
 bool Extension::InitFromValue(const DictionaryValue& source, int flags,
                               std::string* error) {
+  base::AutoLock auto_lock(runtime_data_lock_);
   // When strict error checks are enabled, make URL pattern parsing strict.
   URLPattern::ParseOption parse_strictness =
       (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                    : URLPattern::IGNORE_PORTS);
 
   // Initialize permissions with an empty, default permission set.
-  permission_set_.reset(new ExtensionPermissionSet());
+  runtime_data_.SetActivePermissions(new ExtensionPermissionSet());
+  optional_permission_set_ = new ExtensionPermissionSet();
+  required_permission_set_ = new ExtensionPermissionSet();
 
   if (source.HasKey(keys::kPublicKey)) {
     std::string public_key_bytes;
@@ -1911,104 +1901,30 @@ bool Extension::InitFromValue(const DictionaryValue& source, int flags,
     }
   }
 
+  // Initialize the permissions (optional).
   ExtensionAPIPermissionSet api_permissions;
   URLPatternSet host_permissions;
+  if (!ParsePermissions(&source,
+                        keys::kPermissions,
+                        flags,
+                        error,
+                        &api_permissions,
+                        &host_permissions)) {
+    return false;
+  }
 
-  // Initialize the permissions (optional).
-  if (source.HasKey(keys::kPermissions)) {
-    ListValue* permissions = NULL;
-    if (!source.GetList(keys::kPermissions, &permissions)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
-          errors::kInvalidPermissions, "");
-      return false;
-    }
-
-    for (size_t i = 0; i < permissions->GetSize(); ++i) {
-      std::string permission_str;
-      if (!permissions->GetString(i, &permission_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPermission, base::IntToString(i));
-        return false;
-      }
-
-      ExtensionAPIPermission* permission =
-          ExtensionPermissionsInfo::GetInstance()->GetByName(permission_str);
-
-      // Only COMPONENT extensions can use private APIs.
-      // TODO(asargent) - We want a more general purpose mechanism for this,
-      // and better error messages. (http://crbug.com/54013)
-      if (!IsComponentOnlyPermission(permission)
-#ifndef NDEBUG
-           && !CommandLine::ForCurrentProcess()->HasSwitch(
-                 switches::kExposePrivateExtensionApi)
-#endif
-          ) {
-        continue;
-      }
-
-      if (web_extent().is_empty() || location() == Extension::COMPONENT) {
-        // Check if it's a module permission.  If so, enable that permission.
-        if (permission != NULL) {
-          // Only allow the experimental API permission if the command line
-          // flag is present, or if the extension is a component of Chrome.
-          if (IsDisallowedExperimentalPermission(permission->id()) &&
-              location() != Extension::COMPONENT) {
-            *error = errors::kExperimentalFlagRequired;
-            return false;
-          }
-          api_permissions.insert(permission->id());
-          continue;
-        }
-      } else {
-        // Hosted apps only get access to a subset of the valid permissions.
-        if (permission != NULL && permission->is_hosted_app()) {
-          if (IsDisallowedExperimentalPermission(permission->id())) {
-            *error = errors::kExperimentalFlagRequired;
-            return false;
-          }
-          api_permissions.insert(permission->id());
-          continue;
-        }
-      }
-
-      // Check if it's a host pattern permission.
-      URLPattern pattern = URLPattern(CanExecuteScriptEverywhere() ?
-          URLPattern::SCHEME_ALL : kValidHostPermissionSchemes);
-
-      URLPattern::ParseResult parse_result = pattern.Parse(permission_str,
-                                                           parse_strictness);
-      if (parse_result == URLPattern::PARSE_SUCCESS) {
-        if (!CanSpecifyHostPermission(pattern)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
-              errors::kInvalidPermissionScheme, base::IntToString(i));
-          return false;
-        }
-
-        // The path component is not used for host permissions, so we force it
-        // to match all paths.
-        pattern.SetPath("/*");
-
-        if (pattern.MatchesScheme(chrome::kFileScheme) &&
-            !CanExecuteScriptEverywhere()) {
-          wants_file_access_ = true;
-          if (!(flags & ALLOW_FILE_ACCESS))
-            pattern.SetValidSchemes(
-                pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
-        }
-
-        host_permissions.AddPattern(pattern);
-      }
-
-      // If it's not a host permission, then it's probably an unknown API
-      // permission. Do not throw an error so extensions can retain
-      // backwards compatability (http://crbug.com/42742).
-      // TODO(jstritar): We can improve error messages by adding better
-      // validation of API permissions here.
-      // TODO(skerner): Consider showing the reason |permission_str| is not
-      // a valid URL pattern if it is almost valid.  For example, if it has
-      // a valid scheme, and failed to parse because it has a port, show an
-      // error.
-    }
+  // Initialize the optional permissions (optional).
+  ExtensionAPIPermissionSet optional_api_permissions;
+  URLPatternSet optional_host_permissions;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableExperimentalExtensionApis) &&
+      !ParsePermissions(&source,
+                        keys::kOptionalPermissions,
+                        flags,
+                        error,
+                        &optional_api_permissions,
+                        &optional_host_permissions)) {
+    return false;
   }
 
   // Initialize background url (optional).
@@ -2394,8 +2310,12 @@ bool Extension::InitFromValue(const DictionaryValue& source, int flags,
     return false;
   }
 
-  permission_set_.reset(
-      new ExtensionPermissionSet(this, api_permissions, host_permissions));
+  runtime_data_.SetActivePermissions(new ExtensionPermissionSet(
+      this, api_permissions, host_permissions));
+  required_permission_set_ = new ExtensionPermissionSet(
+      this, api_permissions, host_permissions);
+  optional_permission_set_ = new ExtensionPermissionSet(
+      optional_api_permissions, optional_host_permissions, URLPatternSet());
 
   // Although |source| is passed in as a const, it's still possible to modify
   // it.  This is dangerous since the utility process re-uses |source| after
@@ -2573,6 +2493,118 @@ GURL Extension::GetIconURL(int size,
     return GetResourceURL(path);
 }
 
+bool Extension::ParsePermissions(const DictionaryValue* source,
+                                 const char* key,
+                                 int flags,
+                                 std::string* error,
+                                 ExtensionAPIPermissionSet* api_permissions,
+                                 URLPatternSet* host_permissions) {
+  if (source->HasKey(key)) {
+    // When strict error checks are enabled, make URL pattern parsing strict.
+    URLPattern::ParseOption parse_strictness =
+        (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
+                                     : URLPattern::IGNORE_PORTS);
+    ListValue* permissions = NULL;
+    if (!source->GetList(key, &permissions)) {
+      *error = ExtensionErrorUtils::FormatErrorMessage(
+          errors::kInvalidPermissions, "");
+      return false;
+    }
+
+    for (size_t i = 0; i < permissions->GetSize(); ++i) {
+      std::string permission_str;
+      if (!permissions->GetString(i, &permission_str)) {
+        *error = ExtensionErrorUtils::FormatErrorMessage(
+            errors::kInvalidPermission, base::IntToString(i));
+        return false;
+      }
+
+      ExtensionAPIPermission* permission =
+          ExtensionPermissionsInfo::GetInstance()->GetByName(permission_str);
+
+      // Only COMPONENT extensions can use private APIs.
+      // TODO(asargent) - We want a more general purpose mechanism for this,
+      // and better error messages. (http://crbug.com/54013)
+      if (!IsComponentOnlyPermission(permission)
+#ifndef NDEBUG
+           && !CommandLine::ForCurrentProcess()->HasSwitch(
+                 switches::kExposePrivateExtensionApi)
+#endif
+          ) {
+        continue;
+      }
+
+      if (web_extent().is_empty() || location() == Extension::COMPONENT) {
+        // Check if it's a module permission.  If so, enable that permission.
+        if (permission != NULL) {
+          // Only allow the experimental API permission if the command line
+          // flag is present, or if the extension is a component of Chrome.
+          if (IsDisallowedExperimentalPermission(permission->id()) &&
+              location() != Extension::COMPONENT) {
+            *error = errors::kExperimentalFlagRequired;
+            return false;
+          }
+          api_permissions->insert(permission->id());
+          continue;
+        }
+      } else {
+        // Hosted apps only get access to a subset of the valid permissions.
+        if (permission != NULL && permission->is_hosted_app()) {
+          if (IsDisallowedExperimentalPermission(permission->id())) {
+            *error = errors::kExperimentalFlagRequired;
+            return false;
+          }
+          api_permissions->insert(permission->id());
+          continue;
+        }
+      }
+
+      // Check if it's a host pattern permission.
+      URLPattern pattern = URLPattern(CanExecuteScriptEverywhere() ?
+          URLPattern::SCHEME_ALL : kValidHostPermissionSchemes);
+
+      URLPattern::ParseResult parse_result = pattern.Parse(permission_str,
+                                                           parse_strictness);
+      if (parse_result == URLPattern::PARSE_SUCCESS) {
+        if (!CanSpecifyHostPermission(pattern)) {
+          *error = ExtensionErrorUtils::FormatErrorMessage(
+              errors::kInvalidPermissionScheme, base::IntToString(i));
+          return false;
+        }
+
+        // The path component is not used for host permissions, so we force it
+        // to match all paths.
+        pattern.SetPath("/*");
+
+        if (pattern.MatchesScheme(chrome::kFileScheme) &&
+            !CanExecuteScriptEverywhere()) {
+          wants_file_access_ = true;
+          if (!(flags & ALLOW_FILE_ACCESS))
+            pattern.SetValidSchemes(
+                pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
+        }
+
+        host_permissions->AddPattern(pattern);
+      }
+
+      // If it's not a host permission, then it's probably an unknown API
+      // permission. Do not throw an error so extensions can retain
+      // backwards compatability (http://crbug.com/42742).
+      // TODO(jstritar): We can improve error messages by adding better
+      // validation of API permissions here.
+      // TODO(skerner): Consider showing the reason |permission_str| is not
+      // a valid URL pattern if it is almost valid.  For example, if it has
+      // a valid scheme, and failed to parse because it has a port, show an
+      // error.
+    }
+  }
+  return true;
+}
+
+bool Extension::CanSilentlyIncreasePermissions() const {
+  return location() != INTERNAL;
+}
+
 bool Extension::CanSpecifyHostPermission(const URLPattern& pattern) const {
   if (!pattern.match_all_urls() &&
       pattern.MatchesScheme(chrome::kChromeUIScheme)) {
@@ -2588,24 +2620,68 @@ bool Extension::CanSpecifyHostPermission(const URLPattern& pattern) const {
 
 bool Extension::HasAPIPermission(
     ExtensionAPIPermission::ID permission) const {
-  return permission_set()->HasAPIPermission(permission);
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions()->HasAPIPermission(permission);
 }
 
 bool Extension::HasAPIPermission(
     const std::string& function_name) const {
-  return permission_set()->HasAccessToFunction(function_name);
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions()->
+      HasAccessToFunction(function_name);
 }
 
 const URLPatternSet& Extension::GetEffectiveHostPermissions() const {
-  return permission_set()->effective_hosts();
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions()->effective_hosts();
 }
 
 bool Extension::HasHostPermission(const GURL& url) const {
+  base::AutoLock auto_lock(runtime_data_lock_);
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() != chrome::kChromeUIFaviconHost &&
       location() != Extension::COMPONENT)
     return false;
-  return permission_set()->HasExplicitAccessToOrigin(url);
+  return runtime_data_.GetActivePermissions()->
+      HasExplicitAccessToOrigin(url);
+}
+
+bool Extension::HasEffectiveAccessToAllHosts() const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions()->HasEffectiveAccessToAllHosts();
+}
+
+bool Extension::HasFullPermissions() const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions()->HasEffectiveFullAccess();
+}
+
+ExtensionPermissionMessages Extension::GetPermissionMessages() const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  if (IsTrustedId(id_))
+    return ExtensionPermissionMessages();
+  else
+    return runtime_data_.GetActivePermissions()->GetPermissionMessages();
+}
+
+std::vector<string16> Extension::GetPermissionMessageStrings() const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  if (IsTrustedId(id_))
+    return std::vector<string16>();
+  else
+    return runtime_data_.GetActivePermissions()->GetWarningMessages();
+}
+
+void Extension::SetActivePermissions(
+    const ExtensionPermissionSet* permissions) const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  runtime_data_.SetActivePermissions(permissions);
+}
+
+scoped_refptr<const ExtensionPermissionSet>
+    Extension::GetActivePermissions() const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  return runtime_data_.GetActivePermissions();
 }
 
 bool Extension::IsComponentOnlyPermission(
@@ -2637,6 +2713,7 @@ bool Extension::HasMultipleUISurfaces() const {
 bool Extension::CanExecuteScriptOnPage(const GURL& page_url,
                                        const UserScript* script,
                                        std::string* error) const {
+  base::AutoLock auto_lock(runtime_data_lock_);
   // The gallery is special-cased as a restricted URL for scripting to prevent
   // access to special JS bindings we expose to the gallery (and avoid things
   // like extensions removing the "report abuse" link).
@@ -2661,7 +2738,8 @@ bool Extension::CanExecuteScriptOnPage(const GURL& page_url,
 
   // Otherwise, see if this extension has permission to execute script
   // programmatically on pages.
-  if (permission_set()->HasExplicitAccessToOrigin(page_url))
+  if (runtime_data_.GetActivePermissions()->HasExplicitAccessToOrigin(
+          page_url))
     return true;
 
   if (error) {
@@ -2672,14 +2750,6 @@ bool Extension::CanExecuteScriptOnPage(const GURL& page_url,
   return false;
 }
 
-bool Extension::HasEffectiveAccessToAllHosts() const {
-  return permission_set_->HasEffectiveAccessToAllHosts();
-}
-
-bool Extension::HasFullPermissions() const {
-  return permission_set_->HasEffectiveFullAccess();
-}
-
 bool Extension::ShowConfigureContextMenus() const {
   // Don't show context menu for component extensions. We might want to show
   // options for component extension button but now there is no component
@@ -2767,11 +2837,26 @@ ExtensionInfo::ExtensionInfo(const DictionaryValue* manifest,
 
 ExtensionInfo::~ExtensionInfo() {}
 
+Extension::RuntimeData::RuntimeData() {}
+Extension::RuntimeData::RuntimeData(const ExtensionPermissionSet* active)
+    : active_permissions_(active) {}
+Extension::RuntimeData::~RuntimeData() {}
+
+scoped_refptr<const ExtensionPermissionSet>
+    Extension::RuntimeData::GetActivePermissions() const {
+  return active_permissions_;
+}
+
+void Extension::RuntimeData::SetActivePermissions(
+    const ExtensionPermissionSet* active) {
+  active_permissions_ = active;
+}
+
 UninstalledExtensionInfo::UninstalledExtensionInfo(
     const Extension& extension)
     : extension_id(extension.id()),
       extension_api_permissions(
-          extension.permission_set()->GetAPIsAsStrings()),
+          extension.GetActivePermissions()->GetAPIsAsStrings()),
       extension_type(extension.GetType()),
       update_url(extension.update_url()) {}
 
@@ -2784,3 +2869,11 @@ UnloadedExtensionInfo::UnloadedExtensionInfo(
   : reason(reason),
     already_disabled(false),
     extension(extension) {}
+
+UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
+    const Extension* extension,
+    const ExtensionPermissionSet* permissions,
+    Reason reason)
+    : reason(reason),
+      extension(extension),
+      permissions(permissions) {}
diff --git a/chrome/common/extensions/extension.h b/chrome/common/extensions/extension.h
index a2ee0e7..e46cba1 100644
--- a/chrome/common/extensions/extension.h
+++ b/chrome/common/extensions/extension.h
@@ -16,6 +16,7 @@
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_permission_set.h"
@@ -209,15 +210,6 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
   // its install source should be set to GetHigherPriorityLocation(A, B).
   static Location GetHigherPriorityLocation(Location loc1, Location loc2);
 
-  // Returns the full list of permission messages that this extension
-  // should display at install time.
-  ExtensionPermissionMessages GetPermissionMessages() const;
-
-  // Returns the full list of permission messages that this extension
-  // should display at install time. The messages are returned as strings
-  // for convenience.
-  std::vector<string16> GetPermissionMessageStrings() const;
-
   // Icon sizes used by the extension system.
   static const int kIconSizes[];
 
@@ -375,11 +367,25 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
   static void SetScriptingWhitelist(const ScriptingWhitelist& whitelist);
   static const ScriptingWhitelist* GetScriptingWhitelist();
 
+  // Parses the host and api permissions from the specified permission |key|
+  // in the manifest |source|.
+  bool ParsePermissions(const base::DictionaryValue* source,
+                        const char* key,
+                        int flags,
+                        std::string* error,
+                        ExtensionAPIPermissionSet* api_permissions,
+                        URLPatternSet* host_permissions);
+
   bool HasAPIPermission(ExtensionAPIPermission::ID permission) const;
   bool HasAPIPermission(const std::string& function_name) const;
 
   const URLPatternSet& GetEffectiveHostPermissions() const;
 
+  // Returns true if the extension can silently increase its permission level.
+  // Extensions that can silently increase permissions are installed through
+  // mechanisms that are implicitly trusted.
+  bool CanSilentlyIncreasePermissions() const;
+
   // Whether or not the extension is allowed permission for a URL pattern from
   // the manifest.  http, https, and chrome://favicon/ is allowed for all
   // extensions, while component extensions are allowed access to
@@ -400,6 +406,21 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
   // having an NPAPI plugin).
   bool HasFullPermissions() const;
 
+  // Returns the full list of permission messages that this extension
+  // should display at install time.
+  ExtensionPermissionMessages GetPermissionMessages() const;
+
+  // Returns the full list of permission messages that this extension
+  // should display at install time. The messages are returned as strings
+  // for convenience.
+  std::vector<string16> GetPermissionMessageStrings() const;
+
+  // Sets the active |permissions|.
+  void SetActivePermissions(const ExtensionPermissionSet* permissions) const;
+
+  // Gets the extension's active permission set.
+  scoped_refptr<const ExtensionPermissionSet> GetActivePermissions() const;
+
   // Whether context menu should be shown for page and browser actions.
   bool ShowConfigureContextMenus() const;
 
@@ -494,8 +515,11 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
   const GURL& options_url() const { return options_url_; }
   const GURL& devtools_url() const { return devtools_url_; }
   const std::vector<GURL>& toolstrips() const { return toolstrips_; }
-  const ExtensionPermissionSet* permission_set() const {
-    return permission_set_.get();
+  const ExtensionPermissionSet* optional_permission_set() const {
+    return optional_permission_set_.get();
+  }
+  const ExtensionPermissionSet* required_permission_set() const {
+    return required_permission_set_.get();
   }
   const GURL& update_url() const { return update_url_; }
   const ExtensionIconSet& icons() const { return icons_; }
@@ -551,6 +575,20 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
   typedef std::pair<FilePath, std::string> ImageCacheKey;
   typedef std::map<ImageCacheKey, SkBitmap> ImageCache;
 
+  class RuntimeData {
+   public:
+    RuntimeData();
+    explicit RuntimeData(const ExtensionPermissionSet* active);
+    ~RuntimeData();
+
+    void SetActivePermissions(const ExtensionPermissionSet* active);
+    scoped_refptr<const ExtensionPermissionSet> GetActivePermissions() const;
+
+   private:
+    friend class base::RefCountedThreadSafe<RuntimeData>;
+    scoped_refptr<const ExtensionPermissionSet> active_permissions_;
+  };
+
   // Normalize the path for use by the extension. On Windows, this will make
   // sure the drive letter is uppercase.
   static FilePath MaybeNormalizePath(const FilePath& path);
@@ -673,8 +711,15 @@ class Extension : public base::RefCountedThreadSafe<Extension> {
   // Defines the set of URLs in the extension's web content.
   URLPatternSet extent_;
 
-  // The set of permissions that the extension effectively has access to.
-  scoped_ptr<ExtensionPermissionSet> permission_set_;
+  // The extension runtime data.
+  mutable base::Lock runtime_data_lock_;
+  mutable RuntimeData runtime_data_;
+
+  // The set of permissions the extension can request at runtime.
+  scoped_refptr<const ExtensionPermissionSet> optional_permission_set_;
+
+  // The extension's required / default set of permissions.
+  scoped_refptr<const ExtensionPermissionSet> required_permission_set_;
 
   // The icons for the extension.
   ExtensionIconSet icons_;
@@ -870,4 +915,27 @@ struct UnloadedExtensionInfo {
   UnloadedExtensionInfo(const Extension* extension, Reason reason);
 };
 
+// The details sent for EXTENSION_PERMISSIONS_UPDATED notifications.
+struct UpdatedExtensionPermissionsInfo {
+  enum Reason {
+    ADDED,   // The permissions were added to the extension.
+    REMOVED, // The permissions were removed from the extension.
+  };
+
+  Reason reason;
+
+  // The extension who's permissions have changed.
+  const Extension* extension;
+
+  // The permissions that have changed. For Reason::ADDED, this would contain
+  // only the permissions that have added, and for Reason::REMOVED, this would
+  // only contain the removed permissions.
+  const ExtensionPermissionSet* permissions;
+
+  UpdatedExtensionPermissionsInfo(
+      const Extension* extension,
+      const ExtensionPermissionSet* permissions,
+      Reason reason);
+};
+
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_
diff --git a/chrome/common/extensions/extension_constants.cc b/chrome/common/extensions/extension_constants.cc
index df532ad..a0eb53f 100644
--- a/chrome/common/extensions/extension_constants.cc
+++ b/chrome/common/extensions/extension_constants.cc
@@ -50,6 +50,7 @@ const char* kNaClModulesMIMEType = "mime_type";
 const char* kNaClModulesPath = "path";
 const char* kOmnibox = "omnibox";
 const char* kOmniboxKeyword = "omnibox.keyword";
+const char* kOptionalPermissions = "optional_permissions";
 const char* kOptionsPage = "options_page";
 const char* kPageAction = "page_action";
 const char* kPageActionDefaultIcon = "default_icon";
diff --git a/chrome/common/extensions/extension_constants.h b/chrome/common/extensions/extension_constants.h
index fe2c7bf..5c980e0f 100644
--- a/chrome/common/extensions/extension_constants.h
+++ b/chrome/common/extensions/extension_constants.h
@@ -55,6 +55,7 @@ namespace extension_manifest_keys {
   extern const char* kName;
   extern const char* kOmnibox;
   extern const char* kOmniboxKeyword;
+  extern const char* kOptionalPermissions;
   extern const char* kOptionsPage;
   extern const char* kPageAction;
   extern const char* kPageActionDefaultIcon;
diff --git a/chrome/common/extensions/extension_messages.cc b/chrome/common/extensions/extension_messages.cc
index b388234..fe88896 100644
--- a/chrome/common/extensions/extension_messages.cc
+++ b/chrome/common/extensions/extension_messages.cc
@@ -24,10 +24,14 @@ ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params(
 }
 
 ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params(
-    const Extension* extension)
+    const Extension* extension,
+    const ExtensionPermissionSet* active)
     : manifest(new DictionaryValue()),
       location(extension->location()),
       path(extension->path()),
+      apis(active->apis()),
+      explicit_hosts(active->explicit_hosts()),
+      scriptable_hosts(active->scriptable_hosts()),
       id(extension->id()),
       creation_flags(extension->creation_flags()) {
   // As we need more bits of extension data in the renderer, add more keys to
@@ -65,6 +69,11 @@ scoped_refptr<Extension>
   return extension;
 }
 
+const ExtensionPermissionSet*
+    ExtensionMsg_Loaded_Params::GetActivePermissions() const {
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+
 namespace IPC {
 
 template <>
@@ -101,8 +110,15 @@ bool ParamTraits<URLPattern>::Read(const Message* m, void** iter,
       !ReadParam(m, iter, &spec))
     return false;
 
+  // TODO(jstritar): We don't want the URLPattern to fail parsing when the
+  // scheme is invalid. Instead, the pattern should parse but it should not
+  // match the invalid patterns. We get around this by setting the valid
+  // schemes after parsing the pattern. Update these method calls once we can
+  // ignore scheme validation with URLPattern parse options. crbug.com/90544
+  p->SetValidSchemes(URLPattern::SCHEME_ALL);
+  URLPattern::ParseResult result = p->Parse(spec, URLPattern::IGNORE_PORTS);
   p->SetValidSchemes(valid_schemes);
-  return URLPattern::PARSE_SUCCESS == p->Parse(spec, URLPattern::IGNORE_PORTS);
+  return URLPattern::PARSE_SUCCESS == result;
 }
 
 void ParamTraits<URLPattern>::Log(const param_type& p, std::string* l) {
@@ -116,9 +132,7 @@ void ParamTraits<URLPatternSet>::Write(Message* m, const param_type& p) {
 bool ParamTraits<URLPatternSet>::Read(const Message* m, void** iter,
                                         param_type* p) {
   std::set<URLPattern> patterns;
-  bool success =
-      ReadParam(m, iter, &patterns);
-  if (!success)
+  if (!ReadParam(m, iter, &patterns))
     return false;
 
   for (std::set<URLPattern>::iterator i = patterns.begin();
@@ -131,12 +145,35 @@ void ParamTraits<URLPatternSet>::Log(const param_type& p, std::string* l) {
   LogParam(p.patterns(), l);
 }
 
+void ParamTraits<ExtensionAPIPermission::ID>::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, static_cast<int>(p));
+}
+
+bool ParamTraits<ExtensionAPIPermission::ID>::Read(
+    const Message* m, void** iter, param_type* p) {
+  int api_id = -2;
+  if (!ReadParam(m, iter, &api_id))
+    return false;
+
+  *p = static_cast<ExtensionAPIPermission::ID>(api_id);
+  return true;
+}
+
+void ParamTraits<ExtensionAPIPermission::ID>::Log(
+    const param_type& p, std::string* l) {
+  LogParam(static_cast<int>(p), l);
+}
+
 void ParamTraits<ExtensionMsg_Loaded_Params>::Write(Message* m,
                                                     const param_type& p) {
   WriteParam(m, p.location);
   WriteParam(m, p.path);
   WriteParam(m, *(p.manifest));
   WriteParam(m, p.creation_flags);
+  WriteParam(m, p.apis);
+  WriteParam(m, p.explicit_hosts);
+  WriteParam(m, p.scriptable_hosts);
 }
 
 bool ParamTraits<ExtensionMsg_Loaded_Params>::Read(const Message* m,
@@ -146,7 +183,10 @@ bool ParamTraits<ExtensionMsg_Loaded_Params>::Read(const Message* m,
   return ReadParam(m, iter, &p->location) &&
          ReadParam(m, iter, &p->path) &&
          ReadParam(m, iter, p->manifest.get()) &&
-         ReadParam(m, iter, &p->creation_flags);
+         ReadParam(m, iter, &p->creation_flags) &&
+         ReadParam(m, iter, &p->apis) &&
+         ReadParam(m, iter, &p->explicit_hosts) &&
+         ReadParam(m, iter, &p->scriptable_hosts);
 }
 
 void ParamTraits<ExtensionMsg_Loaded_Params>::Log(const param_type& p,
diff --git a/chrome/common/extensions/extension_messages.h b/chrome/common/extensions/extension_messages.h
index 53abba6..6d41b9c 100644
--- a/chrome/common/extensions/extension_messages.h
+++ b/chrome/common/extensions/extension_messages.h
@@ -8,6 +8,7 @@
 #include "base/shared_memory.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "chrome/common/web_apps.h"
@@ -90,7 +91,9 @@ typedef std::map<std::string, std::string> SubstitutionMap;
 struct ExtensionMsg_Loaded_Params {
   ExtensionMsg_Loaded_Params();
   ~ExtensionMsg_Loaded_Params();
-  explicit ExtensionMsg_Loaded_Params(const Extension* extension);
+  explicit ExtensionMsg_Loaded_Params(
+      const Extension* extension,
+      const ExtensionPermissionSet* active_permissions);
 
   // A copy constructor is needed because this structure can end up getting
   // copied inside the IPC machinery on gcc <= 4.2.
@@ -99,6 +102,9 @@ struct ExtensionMsg_Loaded_Params {
   // Creates a new extension from the data in this object.
   scoped_refptr<Extension> ConvertToExtension() const;
 
+  // Passes ownership to the caller.
+  const ExtensionPermissionSet* GetActivePermissions() const;
+
   // The subset of the extension manifest data we send to renderers.
   scoped_ptr<DictionaryValue> manifest;
 
@@ -109,6 +115,11 @@ struct ExtensionMsg_Loaded_Params {
   // to generate the extension ID for extensions that are loaded unpacked.
   FilePath path;
 
+  // The extension's current active permissions.
+  ExtensionAPIPermissionSet apis;
+  URLPatternSet explicit_hosts;
+  URLPatternSet scriptable_hosts;
+
   // We keep this separate so that it can be used in logging.
   std::string id;
 
@@ -135,6 +146,14 @@ struct ParamTraits<URLPatternSet> {
 };
 
 template <>
+struct ParamTraits<ExtensionAPIPermission::ID> {
+  typedef ExtensionAPIPermission::ID param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
 struct ParamTraits<ExtensionMsg_Loaded_Params> {
   typedef ExtensionMsg_Loaded_Params param_type;
   static void Write(Message* m, const param_type& p);
@@ -214,6 +233,13 @@ IPC_MESSAGE_ROUTED1(ExtensionMsg_GetApplicationInfo,
 IPC_MESSAGE_ROUTED1(ExtensionMsg_UpdateBrowserWindowId,
                     int /* id of browser window */)
 
+// Tell the renderer to update an extension's permission set.
+IPC_MESSAGE_CONTROL4(ExtensionMsg_UpdatePermissions,
+                     std::string /* extension_id*/,
+                     ExtensionAPIPermissionSet,
+                     URLPatternSet,
+                     URLPatternSet)
+
 // Tell the renderer which type this view is.
 IPC_MESSAGE_ROUTED1(ExtensionMsg_NotifyRenderViewType,
                     ViewType::Type /* view_type */)
diff --git a/chrome/common/extensions/extension_permission_set.cc b/chrome/common/extensions/extension_permission_set.cc
index 0fbf2cd..462e022 100644
--- a/chrome/common/extensions/extension_permission_set.cc
+++ b/chrome/common/extensions/extension_permission_set.cc
@@ -247,6 +247,9 @@ ExtensionPermissionsInfo::ExtensionPermissionsInfo()
   RegisterHostedAppPermission(
       ExtensionAPIPermission::kUnlimitedStorage, "unlimitedStorage", 0,
       ExtensionPermissionMessage::kNone);
+  RegisterHostedAppPermission(
+      ExtensionAPIPermission::kPermissions, "permissions", 0,
+      ExtensionPermissionMessage::kNone);
 
   // Hosted app and private permissions.
   RegisterPermission(
@@ -433,12 +436,62 @@ ExtensionPermissionSet::~ExtensionPermissionSet() {
 }
 
 // static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateDifference(
+    const ExtensionPermissionSet* set1,
+    const ExtensionPermissionSet* set2) {
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
+  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
+
+  ExtensionAPIPermissionSet apis;
+  std::set_difference(set1_safe->apis().begin(), set1_safe->apis().end(),
+                      set2_safe->apis().begin(), set2_safe->apis().end(),
+                      std::insert_iterator<ExtensionAPIPermissionSet>(
+                          apis, apis.begin()));
+
+  URLPatternSet explicit_hosts;
+  URLPatternSet::CreateDifference(set1_safe->explicit_hosts(),
+                                  set2_safe->explicit_hosts(),
+                                  &explicit_hosts);
+
+  URLPatternSet scriptable_hosts;
+  URLPatternSet::CreateDifference(set1_safe->scriptable_hosts(),
+                                  set2_safe->scriptable_hosts(),
+                                  &scriptable_hosts);
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+
+// static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateIntersection(
+    const ExtensionPermissionSet* set1,
+    const ExtensionPermissionSet* set2) {
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
+  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
+
+  ExtensionAPIPermissionSet apis;
+  std::set_intersection(set1_safe->apis().begin(), set1_safe->apis().end(),
+                        set2_safe->apis().begin(), set2_safe->apis().end(),
+                        std::insert_iterator<ExtensionAPIPermissionSet>(
+                            apis, apis.begin()));
+  URLPatternSet explicit_hosts;
+  URLPatternSet::CreateIntersection(set1_safe->explicit_hosts(),
+                                    set2_safe->explicit_hosts(),
+                                    &explicit_hosts);
+
+  URLPatternSet scriptable_hosts;
+  URLPatternSet::CreateIntersection(set1_safe->scriptable_hosts(),
+                                    set2_safe->scriptable_hosts(),
+                                    &scriptable_hosts);
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+// static
 ExtensionPermissionSet* ExtensionPermissionSet::CreateUnion(
     const ExtensionPermissionSet* set1,
     const ExtensionPermissionSet* set2) {
-  ExtensionPermissionSet empty;
-  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? &empty : set1;
-  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? &empty : set2;
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
+  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
 
   ExtensionAPIPermissionSet apis;
   std::set_union(set1_safe->apis().begin(), set1_safe->apis().end(),
@@ -447,10 +500,11 @@ ExtensionPermissionSet* ExtensionPermissionSet::CreateUnion(
                      apis, apis.begin()));
 
   URLPatternSet explicit_hosts;
-  URLPatternSet scriptable_hosts;
   URLPatternSet::CreateUnion(set1_safe->explicit_hosts(),
                              set2_safe->explicit_hosts(),
                              &explicit_hosts);
+
+  URLPatternSet scriptable_hosts;
   URLPatternSet::CreateUnion(set1_safe->scriptable_hosts(),
                              set2_safe->scriptable_hosts(),
                              &scriptable_hosts);
@@ -458,6 +512,31 @@ ExtensionPermissionSet* ExtensionPermissionSet::CreateUnion(
   return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
 }
 
+bool ExtensionPermissionSet::operator==(
+    const ExtensionPermissionSet& rhs) const {
+  return apis_ == rhs.apis_ &&
+      scriptable_hosts_ == rhs.scriptable_hosts_ &&
+      explicit_hosts_ == rhs.explicit_hosts_;
+}
+
+bool ExtensionPermissionSet::Contains(const ExtensionPermissionSet& set) const {
+  // Every set includes the empty set.
+  if (set.IsEmpty())
+    return true;
+
+  if (!std::includes(apis_.begin(), apis_.end(),
+                     set.apis().begin(), set.apis().end()))
+    return false;
+
+  if (!explicit_hosts().Contains(set.explicit_hosts()))
+    return false;
+
+  if (!scriptable_hosts().Contains(set.scriptable_hosts()))
+    return false;
+
+  return true;
+}
+
 std::set<std::string> ExtensionPermissionSet::GetAPIsAsStrings() const {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   std::set<std::string> apis_str;
diff --git a/chrome/common/extensions/extension_permission_set.h b/chrome/common/extensions/extension_permission_set.h
index c9a67e9..3d4d353 100644
--- a/chrome/common/extensions/extension_permission_set.h
+++ b/chrome/common/extensions/extension_permission_set.h
@@ -13,6 +13,7 @@
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/singleton.h"
+#include "base/memory/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "chrome/common/extensions/url_pattern_set.h"
@@ -121,6 +122,7 @@ class ExtensionAPIPermission {
     kWebstorePrivate,
     kDevtools,
     kPlugin,
+    kPermissions,
     kEnumBoundary
   };
 
@@ -266,7 +268,8 @@ class ExtensionPermissionsInfo {
 // The ExtensionPermissionSet is an immutable class that encapsulates an
 // extension's permissions. The class exposes set operations for combining and
 // manipulating the permissions.
-class ExtensionPermissionSet {
+class ExtensionPermissionSet
+    : public base::RefCountedThreadSafe<ExtensionPermissionSet> {
  public:
   // Creates an empty permission set (e.g. default permissions).
   ExtensionPermissionSet();
@@ -286,11 +289,26 @@ class ExtensionPermissionSet {
 
   ~ExtensionPermissionSet();
 
+  // Creates a new permission set equal to |set1| - |set2|, passing ownership of
+  // the new set to the caller.
+  static ExtensionPermissionSet* CreateDifference(
+      const ExtensionPermissionSet* set1, const ExtensionPermissionSet* set2);
+
+  // Creates a new permission set equal to the intersection of |set1| and
+  // |set2|, passing ownership of the new set to the caller.
+  static ExtensionPermissionSet* CreateIntersection(
+      const ExtensionPermissionSet* set1, const ExtensionPermissionSet* set2);
+
   // Creates a new permission set equal to the union of |set1| and |set2|.
   // Passes ownership of the new set to the caller.
   static ExtensionPermissionSet* CreateUnion(
       const ExtensionPermissionSet* set1, const ExtensionPermissionSet* set2);
 
+  bool operator==(const ExtensionPermissionSet& rhs) const;
+
+  // Returns true if |set| is a subset of this.
+  bool Contains(const ExtensionPermissionSet& set) const;
+
   // Gets the API permissions in this set as a set of strings.
   std::set<std::string> GetAPIsAsStrings() const;
 
@@ -353,6 +371,8 @@ class ExtensionPermissionSet {
   FRIEND_TEST_ALL_PREFIXES(ExtensionPermissionSetTest,
                            HasLessHostPrivilegesThan);
 
+  friend class base::RefCountedThreadSafe<ExtensionPermissionSet>;
+
   static std::set<std::string> GetDistinctHosts(
       const URLPatternSet& host_patterns, bool include_rcd);
 
@@ -380,9 +400,11 @@ class ExtensionPermissionSet {
   ExtensionAPIPermissionSet apis_;
 
   // The list of hosts that can be accessed directly from the extension.
+  // TODO(jstritar): Rename to "hosts_"?
   URLPatternSet explicit_hosts_;
 
   // The list of hosts that can be scripted by content scripts.
+  // TODO(jstritar): Rename to "user_script_hosts_"?
   URLPatternSet scriptable_hosts_;
 
   // The list of hosts this effectively grants access to.
diff --git a/chrome/common/extensions/extension_permission_set_unittest.cc b/chrome/common/extensions/extension_permission_set_unittest.cc
index b1a08a3..7bba33a 100644
--- a/chrome/common/extensions/extension_permission_set_unittest.cc
+++ b/chrome/common/extensions/extension_permission_set_unittest.cc
@@ -152,6 +152,7 @@ TEST(ExtensionAPIPermissionTest, HostedAppPermissions) {
   hosted_perms.insert(ExtensionAPIPermission::kNotification);
   hosted_perms.insert(ExtensionAPIPermission::kUnlimitedStorage);
   hosted_perms.insert(ExtensionAPIPermission::kWebstorePrivate);
+  hosted_perms.insert(ExtensionAPIPermission::kPermissions);
 
   ExtensionAPIPermissionSet perms = info->GetAll();
   size_t count = 0;
@@ -161,8 +162,8 @@ TEST(ExtensionAPIPermissionTest, HostedAppPermissions) {
     EXPECT_EQ(hosted_perms.count(*i) > 0, info->GetByID(*i)->is_hosted_app());
   }
 
-  EXPECT_EQ(10u, count);
-  EXPECT_EQ(10u, info->get_hosted_app_permission_count());
+  EXPECT_EQ(hosted_perms.size(), count);
+  EXPECT_EQ(hosted_perms.size(), info->get_hosted_app_permission_count());
 }
 
 TEST(ExtensionAPIPermissionTest, ComponentOnlyPermissions) {
@@ -188,17 +189,17 @@ TEST(ExtensionAPIPermissionTest, ComponentOnlyPermissions) {
 
 TEST(ExtensionPermissionSetTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
-  const ExtensionPermissionSet* permissions = NULL;
+  scoped_refptr<const ExtensionPermissionSet> permissions;
 
   extension = LoadManifest("effective_host_permissions", "empty.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_EQ(0u, extension->GetEffectiveHostPermissions().patterns().size());
   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(
       GURL("http://www.google.com")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "one_host.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
       GURL("http://www.google.com")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(
@@ -207,14 +208,14 @@ TEST(ExtensionPermissionSetTest, EffectiveHostPermissions) {
 
   extension = LoadManifest("effective_host_permissions",
                            "one_host_wildcard.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://google.com")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
       GURL("http://foo.google.com")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "two_hosts.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
       GURL("http://www.google.com")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
@@ -223,14 +224,14 @@ TEST(ExtensionPermissionSetTest, EffectiveHostPermissions) {
 
   extension = LoadManifest("effective_host_permissions",
                            "https_not_considered.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://google.com")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("https://google.com")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions",
                            "two_content_scripts.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://google.com")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(
       GURL("http://www.reddit.com")));
@@ -239,7 +240,7 @@ TEST(ExtensionPermissionSetTest, EffectiveHostPermissions) {
   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "all_hosts.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(GURL("https://test/")));
   EXPECT_TRUE(
@@ -247,14 +248,14 @@ TEST(ExtensionPermissionSetTest, EffectiveHostPermissions) {
   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "all_hosts2.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
   EXPECT_TRUE(
       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "all_hosts3.json");
-  permissions = extension->permission_set();
+  permissions = extension->GetActivePermissions();
   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("https://test/")));
   EXPECT_TRUE(
@@ -271,16 +272,17 @@ TEST(ExtensionPermissionSetTest, ExplicitAccessToOrigin) {
   // The explicit host paths should get set to /*.
   AddPattern(&explicit_hosts, "http://www.example.com/a/particular/path/*");
 
-  ExtensionPermissionSet perm_set(apis, explicit_hosts, scriptable_hosts);
-  ASSERT_TRUE(perm_set.HasExplicitAccessToOrigin(
+  scoped_refptr<ExtensionPermissionSet> perm_set = new ExtensionPermissionSet(
+      apis, explicit_hosts, scriptable_hosts);
+  ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://www.google.com/")));
-  ASSERT_TRUE(perm_set.HasExplicitAccessToOrigin(
+  ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://test.google.com/")));
-  ASSERT_TRUE(perm_set.HasExplicitAccessToOrigin(
+  ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://www.example.com")));
-  ASSERT_TRUE(perm_set.HasEffectiveAccessToURL(
+  ASSERT_TRUE(perm_set->HasEffectiveAccessToURL(
       GURL("http://www.example.com")));
-  ASSERT_FALSE(perm_set.HasExplicitAccessToOrigin(
+  ASSERT_FALSE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://test.example.com")));
 }
 
@@ -299,9 +301,9 @@ TEST(ExtensionPermissionSetTest, CreateUnion) {
 
   URLPatternSet effective_hosts;
 
-  scoped_ptr<ExtensionPermissionSet> set1;
-  scoped_ptr<ExtensionPermissionSet> set2;
-  scoped_ptr<ExtensionPermissionSet> union_set;
+  scoped_refptr<ExtensionPermissionSet> set1;
+  scoped_refptr<ExtensionPermissionSet> set2;
+  scoped_refptr<ExtensionPermissionSet> union_set;
 
   // Union with an empty set.
   apis1.insert(ExtensionAPIPermission::kTab);
@@ -313,11 +315,15 @@ TEST(ExtensionPermissionSetTest, CreateUnion) {
   AddPattern(&expected_explicit_hosts, "http://*.google.com/*");
   AddPattern(&effective_hosts, "http://*.google.com/*");
 
-  set1.reset(new ExtensionPermissionSet(
-      apis1, explicit_hosts1, scriptable_hosts1));
-  set2.reset(new ExtensionPermissionSet(
-      apis2, explicit_hosts2, scriptable_hosts2));
-  union_set.reset(ExtensionPermissionSet::CreateUnion(set1.get(), set2.get()));
+  set1 = new ExtensionPermissionSet(apis1, explicit_hosts1, scriptable_hosts1);
+  set2 = new ExtensionPermissionSet(apis2, explicit_hosts2, scriptable_hosts2);
+  union_set = ExtensionPermissionSet::CreateUnion(set1.get(), set2.get());
+  EXPECT_TRUE(set1->Contains(*set2));
+  EXPECT_TRUE(set1->Contains(*union_set));
+  EXPECT_FALSE(set2->Contains(*set1));
+  EXPECT_FALSE(set2->Contains(*union_set));
+  EXPECT_TRUE(union_set->Contains(*set1));
+  EXPECT_TRUE(union_set->Contains(*set2));
 
   EXPECT_FALSE(union_set->HasEffectiveFullAccess());
   EXPECT_EQ(expected_apis, union_set->apis());
@@ -343,9 +349,16 @@ TEST(ExtensionPermissionSetTest, CreateUnion) {
   effective_hosts.ClearPatterns();
   AddPattern(&effective_hosts, "<all_urls>");
 
-  set2.reset(new ExtensionPermissionSet(
-      apis2, explicit_hosts2, scriptable_hosts2));
-  union_set.reset(ExtensionPermissionSet::CreateUnion(set1.get(), set2.get()));
+  set2 = new ExtensionPermissionSet(apis2, explicit_hosts2, scriptable_hosts2);
+  union_set = ExtensionPermissionSet::CreateUnion(set1.get(), set2.get());
+
+  EXPECT_FALSE(set1->Contains(*set2));
+  EXPECT_FALSE(set1->Contains(*union_set));
+  EXPECT_FALSE(set2->Contains(*set1));
+  EXPECT_FALSE(set2->Contains(*union_set));
+  EXPECT_TRUE(union_set->Contains(*set1));
+  EXPECT_TRUE(union_set->Contains(*set2));
+
   EXPECT_TRUE(union_set->HasEffectiveFullAccess());
   EXPECT_TRUE(union_set->HasEffectiveAccessToAllHosts());
   EXPECT_EQ(expected_apis, union_set->apis());
@@ -354,6 +367,146 @@ TEST(ExtensionPermissionSetTest, CreateUnion) {
   EXPECT_EQ(effective_hosts, union_set->effective_hosts());
 }
 
+TEST(ExtensionPermissionSetTest, CreateIntersection) {
+  ExtensionAPIPermissionSet apis1;
+  ExtensionAPIPermissionSet apis2;
+  ExtensionAPIPermissionSet expected_apis;
+
+  URLPatternSet explicit_hosts1;
+  URLPatternSet explicit_hosts2;
+  URLPatternSet expected_explicit_hosts;
+
+  URLPatternSet scriptable_hosts1;
+  URLPatternSet scriptable_hosts2;
+  URLPatternSet expected_scriptable_hosts;
+
+  URLPatternSet effective_hosts;
+
+  scoped_refptr<ExtensionPermissionSet> set1;
+  scoped_refptr<ExtensionPermissionSet> set2;
+  scoped_refptr<ExtensionPermissionSet> new_set;
+
+  // Intersection with an empty set.
+  apis1.insert(ExtensionAPIPermission::kTab);
+  apis1.insert(ExtensionAPIPermission::kBackground);
+
+  AddPattern(&explicit_hosts1, "http://*.google.com/*");
+  AddPattern(&scriptable_hosts1, "http://www.reddit.com/*");
+
+  set1 = new ExtensionPermissionSet(apis1, explicit_hosts1, scriptable_hosts1);
+  set2 = new ExtensionPermissionSet(apis2, explicit_hosts2, scriptable_hosts2);
+  new_set = ExtensionPermissionSet::CreateIntersection(set1.get(), set2.get());
+  EXPECT_TRUE(set1->Contains(*new_set));
+  EXPECT_TRUE(set2->Contains(*new_set));
+  EXPECT_TRUE(set1->Contains(*set2));
+  EXPECT_FALSE(set2->Contains(*set1));
+  EXPECT_FALSE(new_set->Contains(*set1));
+  EXPECT_TRUE(new_set->Contains(*set2));
+
+  EXPECT_TRUE(new_set->IsEmpty());
+  EXPECT_FALSE(new_set->HasEffectiveFullAccess());
+  EXPECT_EQ(expected_apis, new_set->apis());
+  EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
+  EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
+  EXPECT_EQ(expected_explicit_hosts, new_set->effective_hosts());
+
+  // Now use a real second set.
+  apis2.insert(ExtensionAPIPermission::kTab);
+  apis2.insert(ExtensionAPIPermission::kProxy);
+  apis2.insert(ExtensionAPIPermission::kClipboardWrite);
+  apis2.insert(ExtensionAPIPermission::kPlugin);
+  expected_apis.insert(ExtensionAPIPermission::kTab);
+
+  AddPattern(&explicit_hosts2, "http://*.example.com/*");
+  AddPattern(&explicit_hosts2, "http://*.google.com/*");
+  AddPattern(&scriptable_hosts2, "http://*.google.com/*");
+  AddPattern(&expected_explicit_hosts, "http://*.google.com/*");
+
+  effective_hosts.ClearPatterns();
+  AddPattern(&effective_hosts, "http://*.google.com/*");
+
+  set2 = new ExtensionPermissionSet(apis2, explicit_hosts2, scriptable_hosts2);
+  new_set = ExtensionPermissionSet::CreateIntersection(set1.get(), set2.get());
+
+  EXPECT_TRUE(set1->Contains(*new_set));
+  EXPECT_TRUE(set2->Contains(*new_set));
+  EXPECT_FALSE(set1->Contains(*set2));
+  EXPECT_FALSE(set2->Contains(*set1));
+  EXPECT_FALSE(new_set->Contains(*set1));
+  EXPECT_FALSE(new_set->Contains(*set2));
+
+  EXPECT_FALSE(new_set->HasEffectiveFullAccess());
+  EXPECT_FALSE(new_set->HasEffectiveAccessToAllHosts());
+  EXPECT_EQ(expected_apis, new_set->apis());
+  EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
+  EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
+  EXPECT_EQ(effective_hosts, new_set->effective_hosts());
+}
+
+TEST(ExtensionPermissionSetTest, CreateDifference) {
+  ExtensionAPIPermissionSet apis1;
+  ExtensionAPIPermissionSet apis2;
+  ExtensionAPIPermissionSet expected_apis;
+
+  URLPatternSet explicit_hosts1;
+  URLPatternSet explicit_hosts2;
+  URLPatternSet expected_explicit_hosts;
+
+  URLPatternSet scriptable_hosts1;
+  URLPatternSet scriptable_hosts2;
+  URLPatternSet expected_scriptable_hosts;
+
+  URLPatternSet effective_hosts;
+
+  scoped_refptr<ExtensionPermissionSet> set1;
+  scoped_refptr<ExtensionPermissionSet> set2;
+  scoped_refptr<ExtensionPermissionSet> new_set;
+
+  // Difference with an empty set.
+  apis1.insert(ExtensionAPIPermission::kTab);
+  apis1.insert(ExtensionAPIPermission::kBackground);
+
+  AddPattern(&explicit_hosts1, "http://*.google.com/*");
+  AddPattern(&scriptable_hosts1, "http://www.reddit.com/*");
+
+  set1 = new ExtensionPermissionSet(apis1, explicit_hosts1, scriptable_hosts1);
+  set2 = new ExtensionPermissionSet(apis2, explicit_hosts2, scriptable_hosts2);
+  new_set = ExtensionPermissionSet::CreateDifference(set1.get(), set2.get());
+  EXPECT_EQ(*set1, *new_set);
+
+  // Now use a real second set.
+  apis2.insert(ExtensionAPIPermission::kTab);
+  apis2.insert(ExtensionAPIPermission::kProxy);
+  apis2.insert(ExtensionAPIPermission::kClipboardWrite);
+  apis2.insert(ExtensionAPIPermission::kPlugin);
+  expected_apis.insert(ExtensionAPIPermission::kBackground);
+
+  AddPattern(&explicit_hosts2, "http://*.example.com/*");
+  AddPattern(&explicit_hosts2, "http://*.google.com/*");
+  AddPattern(&scriptable_hosts2, "http://*.google.com/*");
+  AddPattern(&expected_scriptable_hosts, "http://www.reddit.com/*");
+
+  effective_hosts.ClearPatterns();
+  AddPattern(&effective_hosts, "http://www.reddit.com/*");
+
+  set2 = new ExtensionPermissionSet(apis2, explicit_hosts2, scriptable_hosts2);
+  new_set = ExtensionPermissionSet::CreateDifference(set1.get(), set2.get());
+
+  EXPECT_TRUE(set1->Contains(*new_set));
+  EXPECT_FALSE(set2->Contains(*new_set));
+
+  EXPECT_FALSE(new_set->HasEffectiveFullAccess());
+  EXPECT_FALSE(new_set->HasEffectiveAccessToAllHosts());
+  EXPECT_EQ(expected_apis, new_set->apis());
+  EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
+  EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
+  EXPECT_EQ(effective_hosts, new_set->effective_hosts());
+
+  // |set3| = |set1| - |set2| --> |set3| intersect |set2| == empty_set
+  set1 = ExtensionPermissionSet::CreateIntersection(new_set.get(), set2.get());
+  EXPECT_TRUE(set1->IsEmpty());
+}
+
 TEST(ExtensionPermissionSetTest, HasLessPrivilegesThan) {
   const struct {
     const char* base_name;
@@ -435,11 +588,13 @@ TEST(ExtensionPermissionSetTest, HasLessPrivilegesThan) {
     if (!new_extension.get())
       continue;
 
-    const ExtensionPermissionSet* old_p = old_extension->permission_set();
-    const ExtensionPermissionSet* new_p = new_extension->permission_set();
+    scoped_refptr<const ExtensionPermissionSet> old_p(
+        old_extension->GetActivePermissions());
+    scoped_refptr<const ExtensionPermissionSet> new_p(
+        new_extension->GetActivePermissions());
 
-    EXPECT_EQ(kTests[i].expect_increase, old_p->HasLessPrivilegesThan(new_p))
-        << kTests[i].base_name;
+    EXPECT_EQ(kTests[i].expect_increase,
+              old_p->HasLessPrivilegesThan(new_p)) << kTests[i].base_name;
   }
 }
 
@@ -491,6 +646,10 @@ TEST(ExtensionPermissionSetTest, PermissionMessages) {
 
   // Warned as part of host permissions.
   skip.insert(ExtensionAPIPermission::kDevtools);
+
+  // This will warn users later, when they request new permissions.
+  skip.insert(ExtensionAPIPermission::kPermissions);
+
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet permissions = info->GetAll();
   for (ExtensionAPIPermissionSet::const_iterator i = permissions.begin();
@@ -538,10 +697,10 @@ TEST(ExtensionPermissionSetTest, DefaultFunctionAccess) {
     { "tabs.getSelected", false},
   };
 
-  ExtensionPermissionSet permissions;
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
-              permissions.HasAccessToFunction(kTests[i].permission_name));
+              empty->HasAccessToFunction(kTests[i].permission_name));
   }
 }
 
@@ -550,7 +709,7 @@ TEST(ExtensionPermissionSetTest, GetWarningMessages_ManyHosts) {
 
   extension = LoadManifest("permissions", "many-hosts.json");
   std::vector<string16> warnings =
-      extension->permission_set()->GetWarningMessages();
+      extension->GetActivePermissions()->GetWarningMessages();
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Your data on encrypted.google.com and www.google.com",
             UTF16ToUTF8(warnings[0]));
@@ -558,11 +717,11 @@ TEST(ExtensionPermissionSetTest, GetWarningMessages_ManyHosts) {
 
 TEST(ExtensionPermissionSetTest, GetWarningMessages_Plugins) {
   scoped_refptr<Extension> extension;
-  scoped_ptr<ExtensionPermissionSet> permissions;
+  scoped_refptr<ExtensionPermissionSet> permissions;
 
   extension = LoadManifest("permissions", "plugins.json");
   std::vector<string16> warnings =
-      extension->permission_set()->GetWarningMessages();
+      extension->GetActivePermissions()->GetWarningMessages();
   // We don't parse the plugins key on Chrome OS, so it should not ask for any
   // permissions.
 #if defined(OS_CHROMEOS)
@@ -575,7 +734,7 @@ TEST(ExtensionPermissionSetTest, GetWarningMessages_Plugins) {
 }
 
 TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
-  scoped_ptr<ExtensionPermissionSet> perm_set;
+  scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   std::set<std::string> expected;
   expected.insert("www.foo.com");
@@ -594,8 +753,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
-    perm_set.reset(new ExtensionPermissionSet(
-       empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -607,8 +766,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.baz.com/path"));
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -618,8 +777,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
     // Add a pattern that differs only by scheme. This should be filtered out.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTPS, "https://www.bar.com/path"));
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -629,8 +788,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
     // Add some dupes by path.
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_HTTP, "http://www.bar.com/pathypath"));
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -646,8 +805,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
     expected.insert("monkey.www.bar.com");
     expected.insert("bar.com");
 
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -677,8 +836,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
 
     expected.insert("www.foo.xyzzy");
 
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -690,8 +849,8 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
 
     expected.insert("*.google.com");
 
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 
@@ -709,14 +868,14 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
     expected.insert("*.google.com");
     expected.insert("*.example.com");
 
-    perm_set.reset(new ExtensionPermissionSet(
-            empty_perms, explicit_hosts, scriptable_hosts));
+    perm_set = new ExtensionPermissionSet(
+        empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 }
 
 TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
-  scoped_ptr<ExtensionPermissionSet> perm_set;
+  scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
@@ -735,13 +894,13 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
 
   std::set<std::string> expected;
   expected.insert("www.foo.com");
-  perm_set.reset(new ExtensionPermissionSet(
-      empty_perms, explicit_hosts, scriptable_hosts));
+  perm_set = new ExtensionPermissionSet(
+      empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
-  scoped_ptr<ExtensionPermissionSet> perm_set;
+  scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
@@ -759,14 +918,14 @@ TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
 
   std::set<std::string> expected;
   expected.insert("www.foo.net");
-  perm_set.reset(new ExtensionPermissionSet(
-      empty_perms, explicit_hosts, scriptable_hosts));
+  perm_set = new ExtensionPermissionSet(
+      empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest,
      GetDistinctHostsForDisplay_OrgIs3rdBestRcd) {
-  scoped_ptr<ExtensionPermissionSet> perm_set;
+  scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
@@ -783,14 +942,14 @@ TEST(ExtensionPermissionSetTest,
 
   std::set<std::string> expected;
   expected.insert("www.foo.org");
-  perm_set.reset(new ExtensionPermissionSet(
-      empty_perms, explicit_hosts, scriptable_hosts));
+  perm_set = new ExtensionPermissionSet(
+      empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
 TEST(ExtensionPermissionSetTest,
      GetDistinctHostsForDisplay_FirstInListIs4thBestRcd) {
-  scoped_ptr<ExtensionPermissionSet> perm_set;
+  scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
@@ -806,8 +965,8 @@ TEST(ExtensionPermissionSetTest,
 
   std::set<std::string> expected;
   expected.insert("www.foo.ca");
-  perm_set.reset(new ExtensionPermissionSet(
-      empty_perms, explicit_hosts, scriptable_hosts));
+  perm_set = new ExtensionPermissionSet(
+      empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
@@ -816,8 +975,8 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   URLPatternSet elist2;
   URLPatternSet slist1;
   URLPatternSet slist2;
-  scoped_ptr<ExtensionPermissionSet> set1;
-  scoped_ptr<ExtensionPermissionSet> set2;
+  scoped_refptr<ExtensionPermissionSet> set1;
+  scoped_refptr<ExtensionPermissionSet> set2;
   ExtensionAPIPermissionSet empty_perms;
   elist1.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
@@ -830,8 +989,8 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
 
-  set1.reset(new ExtensionPermissionSet(empty_perms, elist1, slist1));
-  set2.reset(new ExtensionPermissionSet(empty_perms, elist2, slist2));
+  set1 = new ExtensionPermissionSet(empty_perms, elist1, slist1);
+  set2 = new ExtensionPermissionSet(empty_perms, elist2, slist2);
 
   EXPECT_FALSE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_FALSE(set2->HasLessHostPrivilegesThan(set1.get()));
@@ -840,7 +999,7 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/*"));
-  set2.reset(new ExtensionPermissionSet(empty_perms, elist2, slist2));
+  set2 = new ExtensionPermissionSet(empty_perms, elist2, slist2);
   EXPECT_FALSE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_FALSE(set2->HasLessHostPrivilegesThan(set1.get()));
 
@@ -848,7 +1007,7 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/*"));
-  set2.reset(new ExtensionPermissionSet(empty_perms, elist2, slist2));
+  set2 = new ExtensionPermissionSet(empty_perms, elist2, slist2);
   EXPECT_FALSE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_FALSE(set2->HasLessHostPrivilegesThan(set1.get()));
 
@@ -856,7 +1015,7 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://*.google.com.hk/*"));
-  set2.reset(new ExtensionPermissionSet(empty_perms, elist2, slist2));
+  set2 = new ExtensionPermissionSet(empty_perms, elist2, slist2);
   EXPECT_TRUE(set1->HasLessHostPrivilegesThan(set2.get()));
   //TODO(jstritar): Does not match subdomains properly. http://crbug.com/65337
   //EXPECT_FALSE(set2->HasLessHostPrivilegesThan(set1.get()));
@@ -867,7 +1026,7 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/path"));
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.example.org/path"));
-  set2.reset(new ExtensionPermissionSet(empty_perms, elist2, slist2));
+  set2 = new ExtensionPermissionSet(empty_perms, elist2, slist2);
   EXPECT_TRUE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_FALSE(set2->HasLessHostPrivilegesThan(set1.get()));
 
@@ -875,7 +1034,7 @@ TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://mail.google.com/*"));
-  set2.reset(new ExtensionPermissionSet(empty_perms, elist2, slist2));
+  set2 = new ExtensionPermissionSet(empty_perms, elist2, slist2);
   EXPECT_TRUE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_TRUE(set2->HasLessHostPrivilegesThan(set1.get()));
 }
@@ -889,8 +1048,9 @@ TEST(ExtensionPermissionSetTest, GetAPIsAsStrings) {
   apis.insert(ExtensionAPIPermission::kNotification);
   apis.insert(ExtensionAPIPermission::kTab);
 
-  ExtensionPermissionSet perm_set(apis, empty_set, empty_set);
-  std::set<std::string> api_names = perm_set.GetAPIsAsStrings();
+  scoped_refptr<ExtensionPermissionSet> perm_set = new ExtensionPermissionSet(
+      apis, empty_set, empty_set);
+  std::set<std::string> api_names = perm_set->GetAPIsAsStrings();
 
   // The result is correct if it has the same number of elements
   // and we can convert it back to the id set.
@@ -903,27 +1063,28 @@ TEST(ExtensionPermissionSetTest, IsEmpty) {
   ExtensionAPIPermissionSet empty_apis;
   URLPatternSet empty_extent;
 
-  ExtensionPermissionSet perm_set;
-  EXPECT_TRUE(perm_set.IsEmpty());
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  EXPECT_TRUE(empty->IsEmpty());
+  scoped_refptr<ExtensionPermissionSet> perm_set;
 
-  perm_set = ExtensionPermissionSet(empty_apis, empty_extent, empty_extent);
-  EXPECT_TRUE(perm_set.IsEmpty());
+  perm_set = new ExtensionPermissionSet(empty_apis, empty_extent, empty_extent);
+  EXPECT_TRUE(perm_set->IsEmpty());
 
   ExtensionAPIPermissionSet non_empty_apis;
   non_empty_apis.insert(ExtensionAPIPermission::kBackground);
-  perm_set = ExtensionPermissionSet(
+  perm_set = new ExtensionPermissionSet(
       non_empty_apis, empty_extent, empty_extent);
-  EXPECT_FALSE(perm_set.IsEmpty());
+  EXPECT_FALSE(perm_set->IsEmpty());
 
   // Try non standard host
   URLPatternSet non_empty_extent;
   AddPattern(&non_empty_extent, "http://www.google.com/*");
 
-  perm_set = ExtensionPermissionSet(
+  perm_set = new ExtensionPermissionSet(
       empty_apis, non_empty_extent, empty_extent);
-  EXPECT_FALSE(perm_set.IsEmpty());
+  EXPECT_FALSE(perm_set->IsEmpty());
 
-  perm_set = ExtensionPermissionSet(
+  perm_set = new ExtensionPermissionSet(
       empty_apis, empty_extent, non_empty_extent);
-  EXPECT_FALSE(perm_set.IsEmpty());
+  EXPECT_FALSE(perm_set->IsEmpty());
 }
diff --git a/chrome/common/extensions/extension_unittest.cc b/chrome/common/extensions/extension_unittest.cc
index 79cad1a..5115573 100644
--- a/chrome/common/extensions/extension_unittest.cc
+++ b/chrome/common/extensions/extension_unittest.cc
@@ -389,10 +389,10 @@ TEST(ExtensionTest, EffectiveHostPermissions) {
   hosts = extension->GetEffectiveHostPermissions();
   EXPECT_TRUE(hosts.MatchesURL(GURL("http://google.com")));
   EXPECT_TRUE(hosts.MatchesURL(GURL("http://www.reddit.com")));
-  EXPECT_TRUE(extension->permission_set()->HasEffectiveAccessToURL(
+  EXPECT_TRUE(extension->GetActivePermissions()->HasEffectiveAccessToURL(
       GURL("http://www.reddit.com")));
   EXPECT_TRUE(hosts.MatchesURL(GURL("http://news.ycombinator.com")));
-  EXPECT_TRUE(extension->permission_set()->HasEffectiveAccessToURL(
+  EXPECT_TRUE(extension->GetActivePermissions()->HasEffectiveAccessToURL(
       GURL("http://news.ycombinator.com")));
   EXPECT_FALSE(extension->HasEffectiveAccessToAllHosts());
 
diff --git a/chrome/common/extensions/url_pattern_set.cc b/chrome/common/extensions/url_pattern_set.cc
index 3c8f52c..cf2b9a6 100644
--- a/chrome/common/extensions/url_pattern_set.cc
+++ b/chrome/common/extensions/url_pattern_set.cc
@@ -10,6 +10,29 @@
 #include "chrome/common/extensions/url_pattern.h"
 #include "googleurl/src/gurl.h"
 
+
+// static
+void URLPatternSet::CreateDifference(const URLPatternSet& set1,
+                                     const URLPatternSet& set2,
+                                     URLPatternSet* out) {
+  out->ClearPatterns();
+  std::set_difference(set1.patterns_.begin(), set1.patterns_.end(),
+                      set2.patterns_.begin(), set2.patterns_.end(),
+                      std::inserter<std::set<URLPattern> >(
+                          out->patterns_, out->patterns_.begin()));
+}
+
+// static
+void URLPatternSet::CreateIntersection(const URLPatternSet& set1,
+                                       const URLPatternSet& set2,
+                                       URLPatternSet* out) {
+  out->ClearPatterns();
+  std::set_intersection(set1.patterns_.begin(), set1.patterns_.end(),
+                        set2.patterns_.begin(), set2.patterns_.end(),
+                        std::inserter<std::set<URLPattern> >(
+                            out->patterns_, out->patterns_.begin()));
+}
+
 // static
 void URLPatternSet::CreateUnion(const URLPatternSet& set1,
                                 const URLPatternSet& set2,
@@ -52,6 +75,11 @@ void URLPatternSet::ClearPatterns() {
   patterns_.clear();
 }
 
+bool URLPatternSet::Contains(const URLPatternSet& set) const {
+  return std::includes(patterns_.begin(), patterns_.end(),
+                       set.patterns_.begin(), set.patterns_.end());
+}
+
 bool URLPatternSet::MatchesURL(const GURL& url) const {
   for (URLPatternSet::const_iterator pattern = patterns_.begin();
        pattern != patterns_.end(); ++pattern) {
diff --git a/chrome/common/extensions/url_pattern_set.h b/chrome/common/extensions/url_pattern_set.h
index 1848e74..d26321c 100644
--- a/chrome/common/extensions/url_pattern_set.h
+++ b/chrome/common/extensions/url_pattern_set.h
@@ -18,6 +18,17 @@ class URLPatternSet {
   typedef std::set<URLPattern>::const_iterator const_iterator;
   typedef std::set<URLPattern>::iterator iterator;
 
+  // Clears |out| and populates the set with |set1| - |set2|.
+  static void CreateDifference(const URLPatternSet& set1,
+                               const URLPatternSet& set2,
+                               URLPatternSet* out);
+
+  // Clears |out| and populates the set with the intersection of |set1|
+  // and |set2|.
+  static void CreateIntersection(const URLPatternSet& set1,
+                                 const URLPatternSet& set2,
+                                 URLPatternSet* out);
+
   // Clears |out| and populates the set with the union of |set1| and |set2|.
   static void CreateUnion(const URLPatternSet& set1,
                           const URLPatternSet& set2,
@@ -39,6 +50,9 @@ class URLPatternSet {
   void AddPattern(const URLPattern& pattern);
   void ClearPatterns();
 
+  // Returns true if the permission |set| is a subset of this.
+  bool Contains(const URLPatternSet& set) const;
+
   // Test if the extent contains a URL.
   bool MatchesURL(const GURL& url) const;
 
diff --git a/chrome/common/extensions/url_pattern_set_unittest.cc b/chrome/common/extensions/url_pattern_set_unittest.cc
index f9717ef..ff78d90 100644
--- a/chrome/common/extensions/url_pattern_set_unittest.cc
+++ b/chrome/common/extensions/url_pattern_set_unittest.cc
@@ -7,88 +7,195 @@
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-static const int kAllSchemes =
-    URLPattern::SCHEME_HTTP |
-    URLPattern::SCHEME_HTTPS |
-    URLPattern::SCHEME_FILE |
-    URLPattern::SCHEME_FTP |
-    URLPattern::SCHEME_CHROMEUI;
+namespace {
 
+static void AddPattern(URLPatternSet* set, const std::string& pattern) {
+  int schemes = URLPattern::SCHEME_ALL;
+  set->AddPattern(URLPattern(schemes, pattern));
+}
+
+}
 TEST(URLPatternSetTest, Empty) {
-  URLPatternSet extent;
-  EXPECT_FALSE(extent.MatchesURL(GURL("http://www.foo.com/bar")));
-  EXPECT_FALSE(extent.MatchesURL(GURL()));
-  EXPECT_FALSE(extent.MatchesURL(GURL("invalid")));
+  URLPatternSet set;
+  EXPECT_FALSE(set.MatchesURL(GURL("http://www.foo.com/bar")));
+  EXPECT_FALSE(set.MatchesURL(GURL()));
+  EXPECT_FALSE(set.MatchesURL(GURL("invalid")));
 }
 
 TEST(URLPatternSetTest, One) {
-  URLPatternSet extent;
-  extent.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/*"));
+  URLPatternSet set;
+  AddPattern(&set, "http://www.google.com/*");
 
-  EXPECT_TRUE(extent.MatchesURL(GURL("http://www.google.com/")));
-  EXPECT_TRUE(extent.MatchesURL(GURL("http://www.google.com/monkey")));
-  EXPECT_FALSE(extent.MatchesURL(GURL("https://www.google.com/")));
-  EXPECT_FALSE(extent.MatchesURL(GURL("https://www.microsoft.com/")));
+  EXPECT_TRUE(set.MatchesURL(GURL("http://www.google.com/")));
+  EXPECT_TRUE(set.MatchesURL(GURL("http://www.google.com/monkey")));
+  EXPECT_FALSE(set.MatchesURL(GURL("https://www.google.com/")));
+  EXPECT_FALSE(set.MatchesURL(GURL("https://www.microsoft.com/")));
 }
 
 TEST(URLPatternSetTest, Two) {
-  URLPatternSet extent;
-  extent.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/*"));
-  extent.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/*"));
+  URLPatternSet set;
+  AddPattern(&set, "http://www.google.com/*");
+  AddPattern(&set, "http://www.yahoo.com/*");
 
-  EXPECT_TRUE(extent.MatchesURL(GURL("http://www.google.com/monkey")));
-  EXPECT_TRUE(extent.MatchesURL(GURL("http://www.yahoo.com/monkey")));
-  EXPECT_FALSE(extent.MatchesURL(GURL("https://www.apple.com/monkey")));
+  EXPECT_TRUE(set.MatchesURL(GURL("http://www.google.com/monkey")));
+  EXPECT_TRUE(set.MatchesURL(GURL("http://www.yahoo.com/monkey")));
+  EXPECT_FALSE(set.MatchesURL(GURL("https://www.apple.com/monkey")));
 }
 
 TEST(URLPatternSetTest, OverlapsWith) {
-  URLPatternSet extent1;
-  extent1.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/f*"));
-  extent1.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/b*"));
+  URLPatternSet set1;
+  AddPattern(&set1, "http://www.google.com/f*");
+  AddPattern(&set1, "http://www.yahoo.com/b*");
+
+  URLPatternSet set2;
+  AddPattern(&set2, "http://www.reddit.com/f*");
+  AddPattern(&set2, "http://www.yahoo.com/z*");
+
+  URLPatternSet set3;
+  AddPattern(&set3, "http://www.google.com/q/*");
+  AddPattern(&set3, "http://www.yahoo.com/b/*");
+
+  EXPECT_FALSE(set1.OverlapsWith(set2));
+  EXPECT_FALSE(set2.OverlapsWith(set1));
+
+  EXPECT_TRUE(set1.OverlapsWith(set3));
+  EXPECT_TRUE(set3.OverlapsWith(set1));
+}
+
+TEST(URLPatternSetTest, CreateDifference) {
+  URLPatternSet expected;
+  URLPatternSet set1;
+  URLPatternSet set2;
+  AddPattern(&set1, "http://www.google.com/f*");
+  AddPattern(&set1, "http://www.yahoo.com/b*");
 
-  URLPatternSet extent2;
-  extent2.AddPattern(URLPattern(kAllSchemes, "http://www.reddit.com/f*"));
-  extent2.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/z*"));
+  // Subtract an empty set.
+  URLPatternSet result;
+  URLPatternSet::CreateDifference(set1, set2, &result);
+  EXPECT_EQ(set1, result);
 
-  URLPatternSet extent3;
-  extent3.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/q/*"));
-  extent3.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/b/*"));
+  // Subtract a real set.
+  AddPattern(&set2, "http://www.reddit.com/f*");
+  AddPattern(&set2, "http://www.yahoo.com/z*");
+  AddPattern(&set2, "http://www.google.com/f*");
 
-  EXPECT_FALSE(extent1.OverlapsWith(extent2));
-  EXPECT_FALSE(extent2.OverlapsWith(extent1));
+  AddPattern(&expected, "http://www.yahoo.com/b*");
 
-  EXPECT_TRUE(extent1.OverlapsWith(extent3));
-  EXPECT_TRUE(extent3.OverlapsWith(extent1));
+  result.ClearPatterns();
+  URLPatternSet::CreateDifference(set1, set2, &result);
+  EXPECT_EQ(expected, result);
+  EXPECT_FALSE(result.is_empty());
+  EXPECT_TRUE(set1.Contains(result));
+  EXPECT_FALSE(result.Contains(set2));
+  EXPECT_FALSE(set2.Contains(result));
+
+  URLPatternSet intersection;
+  URLPatternSet::CreateIntersection(result, set2, &intersection);
+  EXPECT_TRUE(intersection.is_empty());
+}
+
+TEST(URLPatternSetTest, CreateIntersection) {
+  URLPatternSet empty_set;
+  URLPatternSet expected;
+  URLPatternSet set1;
+  AddPattern(&set1, "http://www.google.com/f*");
+  AddPattern(&set1, "http://www.yahoo.com/b*");
+
+  // Intersection with an empty set.
+  URLPatternSet result;
+  URLPatternSet::CreateIntersection(set1, empty_set, &result);
+  EXPECT_EQ(expected, result);
+  EXPECT_TRUE(result.is_empty());
+  EXPECT_TRUE(empty_set.Contains(result));
+  EXPECT_TRUE(result.Contains(empty_set));
+  EXPECT_TRUE(set1.Contains(result));
+
+  // Intersection with a real set.
+  URLPatternSet set2;
+  AddPattern(&set2, "http://www.reddit.com/f*");
+  AddPattern(&set2, "http://www.yahoo.com/z*");
+  AddPattern(&set2, "http://www.google.com/f*");
+
+  AddPattern(&expected, "http://www.google.com/f*");
+
+  result.ClearPatterns();
+  URLPatternSet::CreateIntersection(set1, set2, &result);
+  EXPECT_EQ(expected, result);
+  EXPECT_FALSE(result.is_empty());
+  EXPECT_TRUE(set1.Contains(result));
+  EXPECT_TRUE(set2.Contains(result));
 }
 
 TEST(URLPatternSetTest, CreateUnion) {
-  URLPatternSet empty_extent;
+  URLPatternSet empty_set;
 
-  URLPatternSet extent1;
-  extent1.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/f*"));
-  extent1.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/b*"));
+  URLPatternSet set1;
+  AddPattern(&set1, "http://www.google.com/f*");
+  AddPattern(&set1, "http://www.yahoo.com/b*");
 
   URLPatternSet expected;
-  expected.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/f*"));
-  expected.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/b*"));
+  AddPattern(&expected, "http://www.google.com/f*");
+  AddPattern(&expected, "http://www.yahoo.com/b*");
 
   // Union with an empty set.
   URLPatternSet result;
-  URLPatternSet::CreateUnion(extent1, empty_extent, &result);
+  URLPatternSet::CreateUnion(set1, empty_set, &result);
   EXPECT_EQ(expected, result);
 
-  // Union with a real set (including a duplicate).
-  URLPatternSet extent2;
-  extent2.AddPattern(URLPattern(kAllSchemes, "http://www.reddit.com/f*"));
-  extent2.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/z*"));
-  extent2.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/f*"));
+  // Union with a real set.
+  URLPatternSet set2;
+  AddPattern(&set2, "http://www.reddit.com/f*");
+  AddPattern(&set2, "http://www.yahoo.com/z*");
+  AddPattern(&set2, "http://www.google.com/f*");
 
-  expected.AddPattern(URLPattern(kAllSchemes, "http://www.reddit.com/f*"));
-  expected.AddPattern(URLPattern(kAllSchemes, "http://www.yahoo.com/z*"));
-  // CreateUnion does not filter out duplicates right now.
-  expected.AddPattern(URLPattern(kAllSchemes, "http://www.google.com/f*"));
+  AddPattern(&expected, "http://www.reddit.com/f*");
+  AddPattern(&expected, "http://www.yahoo.com/z*");
 
   result.ClearPatterns();
-  URLPatternSet::CreateUnion(extent1, extent2, &result);
+  URLPatternSet::CreateUnion(set1, set2, &result);
   EXPECT_EQ(expected, result);
 }
+
+TEST(URLPatternSetTest, Contains) {
+  URLPatternSet set1;
+  URLPatternSet set2;
+  URLPatternSet empty_set;
+
+  AddPattern(&set1, "http://www.google.com/*");
+  AddPattern(&set1, "http://www.yahoo.com/*");
+
+  AddPattern(&set2, "http://www.reddit.com/*");
+
+  EXPECT_FALSE(set1.Contains(set2));
+  EXPECT_TRUE(set1.Contains(empty_set));
+  EXPECT_FALSE(empty_set.Contains(set1));
+
+  AddPattern(&set2, "http://www.yahoo.com/*");
+
+  EXPECT_FALSE(set1.Contains(set2));
+  EXPECT_FALSE(set2.Contains(set1));
+
+  AddPattern(&set2, "http://www.google.com/*");
+
+  EXPECT_FALSE(set1.Contains(set2));
+  EXPECT_TRUE(set2.Contains(set1));
+
+  // Note that this just checks pattern equality, and not if individual patterns
+  // contain other patterns. For example:
+  AddPattern(&set1, "http://*.reddit.com/*");
+  EXPECT_FALSE(set1.Contains(set2));
+  EXPECT_FALSE(set2.Contains(set1));
+}
+
+TEST(URLPatternSetTest, Duplicates) {
+  URLPatternSet set1;
+  URLPatternSet set2;
+
+  AddPattern(&set1, "http://www.google.com/*");
+  AddPattern(&set2, "http://www.google.com/*");
+
+  AddPattern(&set1, "http://www.google.com/*");
+
+  // The sets should still be equal after adding a duplicate.
+  EXPECT_EQ(set2, set1);
+}
diff --git a/chrome/renderer/extensions/extension_dispatcher.cc b/chrome/renderer/extensions/extension_dispatcher.cc
index 098e3e5..d994d92 100644
--- a/chrome/renderer/extensions/extension_dispatcher.cc
+++ b/chrome/renderer/extensions/extension_dispatcher.cc
@@ -9,6 +9,7 @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
+#include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/chrome_app_bindings.h"
 #include "chrome/renderer/extensions/event_bindings.h"
@@ -65,6 +66,7 @@ bool ExtensionDispatcher::OnControlMessageReceived(
                         OnSetScriptingWhitelist)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateApplication, OnActivateApplication)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePermissions, OnUpdatePermissions)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateUserScripts, OnUpdateUserScripts)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ -149,6 +151,7 @@ void ExtensionDispatcher::OnLoaded(const ExtensionMsg_Loaded_Params& params) {
   }
 
   extensions_.Insert(extension);
+  extension->SetActivePermissions(params.GetActivePermissions());
 }
 
 void ExtensionDispatcher::OnUnloaded(const std::string& id) {
@@ -244,7 +247,7 @@ void ExtensionDispatcher::InitHostPermissions(const Extension* extension) {
   }
 
   const URLPatternSet& permissions =
-      extension->permission_set()->explicit_hosts();
+      extension->GetActivePermissions()->explicit_hosts();
   for (URLPatternSet::const_iterator i = permissions.begin();
        i != permissions.end(); ++i) {
     const char* schemes[] = {
@@ -265,6 +268,19 @@ void ExtensionDispatcher::InitHostPermissions(const Extension* extension) {
   }
 }
 
+void ExtensionDispatcher::OnUpdatePermissions(
+    const std::string& extension_id,
+    const ExtensionAPIPermissionSet& apis,
+    const URLPatternSet& explicit_hosts,
+    const URLPatternSet& scriptable_hosts) {
+  const Extension* extension = extensions_.GetByID(extension_id);
+  if (!extension)
+    return;
+
+  extension->SetActivePermissions(
+      new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts));
+}
+
 void ExtensionDispatcher::OnUpdateUserScripts(
     base::SharedMemoryHandle scripts) {
   DCHECK(base::SharedMemory::IsHandleValid(scripts)) << "Bad scripts handle";
diff --git a/chrome/renderer/extensions/extension_dispatcher.h b/chrome/renderer/extensions/extension_dispatcher.h
index f2ae6fe9..f1fb8e4 100644
--- a/chrome/renderer/extensions/extension_dispatcher.h
+++ b/chrome/renderer/extensions/extension_dispatcher.h
@@ -20,6 +20,7 @@ class RenderThread;
 class URLPattern;
 class UserScriptSlave;
 struct ExtensionMsg_Loaded_Params;
+struct ExtensionMsg_UpdatePermissions_Params;
 
 namespace base {
 class ListValue;
@@ -77,6 +78,10 @@ class ExtensionDispatcher : public RenderProcessObserver {
       const std::vector<std::string>& page_actions);
   void OnActivateApplication(const std::string& extension_id);
   void OnActivateExtension(const std::string& extension_id);
+  void OnUpdatePermissions(const std::string& extension_id,
+                           const ExtensionAPIPermissionSet& apis,
+                           const URLPatternSet& explicit_hosts,
+                           const URLPatternSet& scriptable_hosts);
   void OnUpdateUserScripts(base::SharedMemoryHandle table);
 
   // Update the list of active extensions that will be reported when we crash.
diff --git a/chrome/renderer/resources/extension_apitest.js b/chrome/renderer/resources/extension_apitest.js
index c09ed57..7e7e62f 100644
--- a/chrome/renderer/resources/extension_apitest.js
+++ b/chrome/renderer/resources/extension_apitest.js
@@ -71,7 +71,7 @@ var chrome = chrome || {};
       if (pendingCallbacks == 0) {
         chrome.test.succeed();
       }
-    }
+    };
   };
 
   chrome.test.runNextTest = function() {
diff --git a/chrome/renderer/resources/renderer_extension_bindings.js b/chrome/renderer/resources/renderer_extension_bindings.js
index 6935c1d..b78b4c1 100644
--- a/chrome/renderer/resources/renderer_extension_bindings.js
+++ b/chrome/renderer/resources/renderer_extension_bindings.js
@@ -310,6 +310,7 @@ var chrome = chrome || {};
       "experimental.input",
       "experimental.inputUI",
       "experimental.metrics",
+      "experimental.permissions",
       "experimental.popup",
       "experimental.processes",
       "experimental.rlz",
diff --git a/chrome/test/data/extensions/api_test/permissions/experimental_disabled/background.html b/chrome/test/data/extensions/api_test/permissions/experimental_disabled/background.html
index c46b2e8..4f27694 100644
--- a/chrome/test/data/extensions/api_test/permissions/experimental_disabled/background.html
+++ b/chrome/test/data/extensions/api_test/permissions/experimental_disabled/background.html
@@ -6,7 +6,7 @@ chrome.test.runTests([
   function experimental() {

     chrome.tabs.getSelected(null, function(tab) {

       try {

-        chrome.experimental.processes.getProcessForTab(tab.id, 

+        chrome.experimental.processes.getProcessForTab(tab.id,

                                                        function(process) {

           chrome.test.fail();

         });

diff --git a/chrome/test/data/extensions/api_test/permissions/optional/background.html b/chrome/test/data/extensions/api_test/permissions/optional/background.html
new file mode 100644
index 0000000..ba9a1c8
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/permissions/optional/background.html
@@ -0,0 +1,188 @@
+<script>

+

+var assertFalse = chrome.test.assertFalse;

+var assertTrue = chrome.test.assertTrue;

+var fail = chrome.test.callbackFail;

+var pass = chrome.test.callbackPass;

+var listenOnce = chrome.test.listenOnce;

+

+var NOT_OPTIONAL_ERROR =

+    "Optional permissions must be listed in extension manifest.";

+

+var NO_TABS_PERMISSION =

+    "You do not have permission to use 'windows.getAll'.";

+

+var REQUIRED_ERROR =

+    "You cannot remove required permissions.";

+

+var NOT_WHITE_LISTED_ERROR =

+    "The optional permissions API does not support '*'.";

+

+var UNKNOWN_PERMISSIONS_ERROR =

+    "'*' is not a recognized permission.";

+

+var emptyPermissions = {permissions: []};

+

+var initialPermissions = {

+  permissions: ['experimental', 'management', 'permissions']

+};

+

+var permissionsWithTabs = {

+  permissions: ['experimental', 'management', 'permissions', 'tabs']

+}

+

+function checkEqualSets(set1, set2) {

+  if (set1.length != set2.length)

+    return false;

+

+  for (var x = 0; x < set1.length; x++) {

+    if (!set2.some(function(v) { return v == set1[x]; }))

+      return false;

+  }

+

+  return true;

+}

+

+function checkPermSetsEq(set1, set2) {

+  return checkEqualSets(set1.permissions, set2.permissions);

+}

+

+chrome.test.runTests([

+  function contains() {

+    chrome.experimental.permissions.contains(

+      {permissions: ['management']},

+      pass(function(result) {

+        assertTrue(result);

+    }));

+    chrome.experimental.permissions.contains(

+      {permissions: ['devtools']},

+      pass(function(result) {

+        assertFalse(result);

+    }));

+    chrome.experimental.permissions.contains(

+      {permissions: ['permissions', 'management']},

+      pass(function(result) {

+        assertTrue(result);

+    }));

+    chrome.experimental.permissions.contains(

+      {permissions: ['management', 'permissions']},

+      pass(function(result) {

+        assertTrue(result);

+    }));

+  },

+

+  function getAll() {

+    chrome.experimental.permissions.getAll(pass(function(permissions) {

+      assertTrue(checkPermSetsEq(initialPermissions, permissions));

+    }));

+  },

+

+  // Nothing should happen if we request permission we already have

+  function requestNoOp() {

+    chrome.experimental.permissions.request(

+      {permissions:['management']},

+      pass(function(granted) {

+        assertTrue(granted);

+    }));

+  },

+

+  // We should get an error when requesting permissions that haven't been

+  // defined in "optional_permissions".

+  function requestNonOptional() {

+    chrome.experimental.permissions.request(

+        {permissions:['debugger']}, fail(NOT_OPTIONAL_ERROR));

+  },

+

+  // We should be able to request the tabs API since it's in the granted

+  // permissions list (see permissions_apitest.cc).

+  function requestTabs() {

+    try {

+      chrome.windows.getAll({populate: true}, function() {

+        chrome.test.fail("Should not have tabs API permission.");

+      });

+    } catch (e) {

+      assertTrue(e.message.indexOf(NO_TABS_PERMISSION) == 0);

+    }

+    listenOnce(chrome.experimental.permissions.onAdded, function(permissions) {

+      assertTrue(permissions.permissions.length == 1);

+      assertTrue(permissions.permissions[0] == 'tabs');

+    });

+    chrome.experimental.permissions.request(

+      {permissions:['tabs']},

+      pass(function(granted) {

+        assertTrue(granted);

+        chrome.windows.getAll({populate: true}, pass(function(windows) {

+          assertTrue(true);

+        }));

+        chrome.experimental.permissions.getAll(pass(function(permissions) {

+          assertTrue(checkPermSetsEq(permissionsWithTabs, permissions));

+        }));

+    }));

+  },

+

+  // You can't remove required permissions.

+  function removeRequired() {

+    chrome.experimental.permissions.remove(

+        {permissions:['management']}, fail(REQUIRED_ERROR));

+  },

+

+  // You can remove permissions you don't have (nothing happens).

+  function removeNoOp() {

+    chrome.experimental.permissions.remove(

+      {permissions:['background']},

+      pass(function(removed) {

+        assertTrue(removed);

+    }));

+  },

+

+  function removeTabs() {

+    chrome.windows.getAll({populate: true}, pass(function(windows) {

+      assertTrue(true);

+    }));

+    listenOnce(chrome.experimental.permissions.onRemoved,

+               function(permissions) {

+      assertTrue(permissions.permissions.length == 1);

+      assertTrue(permissions.permissions[0] == 'tabs');

+    });

+    chrome.experimental.permissions.remove(

+      {permissions:['tabs']},

+      pass(function() {

+        chrome.experimental.permissions.getAll(pass(function(permissions) {

+          assertTrue(checkPermSetsEq(initialPermissions, permissions));

+        }));

+        try {

+          chrome.windows.getAll({populate: true}, function() {

+            chrome.test.fail("Should not have tabs API permission.");

+          });

+        } catch (e) {

+          assertTrue(e.message.indexOf(NO_TABS_PERMISSION) == 0);

+        }

+    }));

+  },

+

+  // The user shouldn't have to approve permissions that have no warnings.

+  // TODO(jstritar): move to its own test and set a low timeout

+  function noPromptForNoWarnings() {

+    chrome.experimental.permissions.request(

+      {permissions: ['notifications']},

+      pass(function(granted) {

+        assertTrue(granted);

+    }));

+  },

+

+  // Make sure you can only access the white listed permissions.

+  function whitelist() {

+    var error_msg = NOT_WHITE_LISTED_ERROR.replace('*', 'chromeAuthPrivate');

+    chrome.experimental.permissions.request(

+        {permissions: ['chromeAuthPrivate']}, fail(error_msg));

+    chrome.experimental.permissions.remove(

+        {permissions: ['chromeAuthPrivate']}, fail(error_msg));

+  },

+

+  function unknownPermission() {

+    var error_msg = UNKNOWN_PERMISSIONS_ERROR.replace('*', 'asdf');

+    chrome.experimental.permissions.request(

+      {permissions: ['asdf']}, fail(error_msg));

+  }

+]);

+</script>

diff --git a/chrome/test/data/extensions/api_test/permissions/optional/manifest.json b/chrome/test/data/extensions/api_test/permissions/optional/manifest.json
new file mode 100644
index 0000000..55ea80b
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/permissions/optional/manifest.json
@@ -0,0 +1,19 @@
+{
+   "name": "permissions/optional",
+   "description": "permissions/optional",
+   "key": "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDkprt3BRSqoikAhSygI6VUzDLt18cKODYmkaa/dwPp4dboyz93RSB+v76grbqsNWrJjkrEwRD3QFeBYBq7h27XAMV4X5XvWjmWQBkRTBQyQI8cZd7M9dgfKrI3EqX9OJvd/wTJkC0dgF47nwWRa/Tvwl7Y66GwEEUjpn2MTv4klwIDAQAB",
+   "version": "0.1",
+   "background_page": "background.html",
+   "permissions": [ 
+     "experimental",
+     "management",
+     "permissions",
+     "http://example.org/"
+   ],
+   "optional_permissions": [
+     "tabs",
+     "management",
+     "notifications",
+     "background"
+   ]
+}
diff --git a/chrome/test/data/extensions/api_test/permissions/optional_deny/background.html b/chrome/test/data/extensions/api_test/permissions/optional_deny/background.html
new file mode 100644
index 0000000..ca02382
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/permissions/optional_deny/background.html
@@ -0,0 +1,36 @@
+<script>

+

+var assertFalse = chrome.test.assertFalse;

+var assertTrue = chrome.test.assertTrue;

+var pass = chrome.test.callbackPass;

+

+var NO_TABS_PERMISSION =

+    "You do not have permission to use 'windows.getAll'.";

+

+chrome.test.runTests([

+  function denyRequest() {

+    chrome.experimental.permissions.request(
+      {permissions: ['tabs']},
+      pass(function(granted) {

+        // They were not granted, and there should be no error.

+        assertFalse(granted);

+        assertTrue(chrome.extension.lastError === undefined);

+

+        // Make sure they weren't granted...

+        chrome.experimental.permissions.contains(
+          {permissions: ['tabs']},

+          pass(function(result) {

+            assertFalse(result);

+        }));

+

+        try {

+          chrome.windows.getAll({populate: true}, function() {

+            chrome.test.fail("Should not have tabs API permission.");

+          });

+        } catch (e) {

+          assertTrue(e.message.indexOf(NO_TABS_PERMISSION) == 0);

+        }

+    }));

+  }

+]);

+</script>

diff --git a/chrome/test/data/extensions/api_test/permissions/optional_deny/manifest.json b/chrome/test/data/extensions/api_test/permissions/optional_deny/manifest.json
new file mode 100644
index 0000000..e3b668c
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/permissions/optional_deny/manifest.json
@@ -0,0 +1,8 @@
+{
+   "name": "permissions/optional_deny",
+   "description": "permissions/optional_deny",
+   "version": "0.1",
+   "background_page": "background.html",
+   "permissions": ["experimental", "permissions", "http://example.org/"],
+   "optional_permissions": ["tabs", "management"]
+}