Add origin permissions to the extension permissions API.

chrome/renderer/extensions/extension_dispatcher.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 
 #include "base/command_line.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 80 matching lines @@
   RegisterExtension(EventBindings::Get(this), true);
   RegisterExtension(RendererExtensionBindings::Get(this), true);
   RegisterExtension(ExtensionApiTestV8Extension::Get(), true);
 
   // Initialize host permissions for any extensions that were activated before
   // WebKit was initialized.
   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
        iter != active_extension_ids_.end(); ++iter) {
     const Extension* extension = extensions_.GetByID(*iter);
     if (extension)
-      InitHostPermissions(extension);
+      InitOriginPermissions(extension);
   }
 
   is_webkit_initialized_ = true;
 }
 
 void ExtensionDispatcher::IdleNotification() {
   if (is_extension_process_) {
     // Dampen the forced delay as well if the extension stays idle for long
     // periods of time.
     int64 forced_delay_s = std::max(static_cast<int64>(
@@ skipping 115 matching lines @@
   RenderThread::current()->ScheduleIdleHandler(
       kInitialExtensionIdleHandlerDelayS);
 
   UpdateActiveExtensions();
 
   const Extension* extension = extensions_.GetByID(extension_id);
   if (!extension)
     return;
 
   if (is_webkit_initialized_)
-    InitHostPermissions(extension);
+    InitOriginPermissions(extension);
 }
 
-void ExtensionDispatcher::InitHostPermissions(const Extension* extension) {
+void ExtensionDispatcher::InitOriginPermissions(const Extension* extension) {
+  // TODO(jstritar): We should try to remove this special case. Also, these
+  // whitelist entries need to be updated when the kManagement permission
+  // changes.
   if (extension->HasAPIPermission(ExtensionAPIPermission::kManagement)) {
     WebSecurityPolicy::addOriginAccessWhitelistEntry(
         extension->url(),
         WebString::fromUTF8(chrome::kChromeUIScheme),
         WebString::fromUTF8(chrome::kChromeUIExtensionIconHost),
         false);
   }
 
-  const URLPatternSet& permissions =
-      extension->GetActivePermissions()->explicit_hosts();
-  for (URLPatternSet::const_iterator i = permissions.begin();
-       i != permissions.end(); ++i) {
+  UpdateOriginPermissions(UpdatedExtensionPermissionsInfo::ADDED,
+                          extension,
+                          extension->GetActivePermissions()->explicit_hosts());
+}
+
+void ExtensionDispatcher::UpdateOriginPermissions(
+    UpdatedExtensionPermissionsInfo::Reason reason,
+    const Extension* extension,
+    const URLPatternSet& origins) {
+  for (URLPatternSet::const_iterator i = origins.begin();
+       i != origins.end(); ++i) {
     const char* schemes[] = {
       chrome::kHttpScheme,
       chrome::kHttpsScheme,
       chrome::kFileScheme,
       chrome::kChromeUIScheme,
     };
     for (size_t j = 0; j < arraysize(schemes); ++j) {
       if (i->MatchesScheme(schemes[j])) {
-        WebSecurityPolicy::addOriginAccessWhitelistEntry(
-            extension->url(),
-            WebString::fromUTF8(schemes[j]),
-            WebString::fromUTF8(i->host()),
-            i->match_subdomains());
+        ((reason == UpdatedExtensionPermissionsInfo::REMOVED) ?
+         WebSecurityPolicy::removeOriginAccessWhitelistEntry :
+         WebSecurityPolicy::addOriginAccessWhitelistEntry)(
+              extension->url(),
+              WebString::fromUTF8(schemes[j]),
+              WebString::fromUTF8(i->host()),
+              i->match_subdomains());
       }
     }
   }
 }
 
 void ExtensionDispatcher::OnUpdatePermissions(
+    int reason_id,
     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));
+  scoped_refptr<const ExtensionPermissionSet> delta =
+      new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+  scoped_refptr<const ExtensionPermissionSet> old_active =
+      extension->GetActivePermissions();
+  UpdatedExtensionPermissionsInfo::Reason reason =
+      static_cast<UpdatedExtensionPermissionsInfo::Reason>(reason_id);
+
+  const ExtensionPermissionSet* new_active = NULL;
+  if (reason == UpdatedExtensionPermissionsInfo::ADDED) {
+    new_active = ExtensionPermissionSet::CreateUnion(old_active, delta);
+  } else {
+    CHECK_EQ(UpdatedExtensionPermissionsInfo::REMOVED, reason);
+    new_active = ExtensionPermissionSet::CreateDifference(old_active, delta);
+  }
+
+  extension->SetActivePermissions(new_active);
+  UpdateOriginPermissions(reason, extension, explicit_hosts);
 }
 
 void ExtensionDispatcher::OnUpdateUserScripts(
     base::SharedMemoryHandle scripts) {
   DCHECK(base::SharedMemory::IsHandleValid(scripts)) << "Bad scripts handle";
   user_script_slave_->UpdateScripts(scripts);
   UpdateActiveExtensions();
 }
 
 void ExtensionDispatcher::UpdateActiveExtensions() {
   // In single-process mode, the browser process reports the active extensions.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess))
     return;
 
   std::set<std::string> active_extensions = active_extension_ids_;
   user_script_slave_->GetActiveExtensions(&active_extensions);
   child_process_logging::SetActiveExtensions(active_extensions);
 }
 
 void ExtensionDispatcher::RegisterExtension(v8::Extension* extension,
                                             bool restrict_to_extensions) {
   if (restrict_to_extensions)
     restricted_v8_extensions_.insert(extension->name());
 
   RenderThread::current()->RegisterExtension(extension);
 }