Support "always allow" for runtime script execution

chrome/browser/extensions/permissions_updater.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/permissions_updater.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 168 matching lines @@
                                      bounded_active->manifest_permissions(),
                                      granted_explicit_hosts,
                                      granted_scriptable_hosts);
 
   scoped_refptr<const PermissionSet> withheld =
       new PermissionSet(APIPermissionSet(),
                         ManifestPermissionSet(),
                         withheld_explicit_hosts,
                         withheld_scriptable_hosts);
   SetPermissions(extension, bounded_active, withheld);
+  ActivateGrantedHosts(extension);

[gpdavis, 2014/08/07 20:50:39]

Once we're done initializing permissions (we use BoundedActivePermissions to set
up granted and withheld permissions within this function), we call
ActivateGrantedHosts...

 }
 
 void PermissionsUpdater::WithholdImpliedAllHosts(const Extension* extension) {
   scoped_refptr<const PermissionSet> active =
       extension->permissions_data()->active_permissions();
   scoped_refptr<const PermissionSet> withheld =
       extension->permissions_data()->withheld_permissions();
 
   URLPatternSet withheld_scriptable = withheld->scriptable_hosts();
   URLPatternSet active_scriptable;
@@ skipping 44 matching lines @@
   // permissions will be empty.
   SetPermissions(extension,
                  new PermissionSet(active->apis(),
                                    active->manifest_permissions(),
                                    explicit_hosts,
                                    scriptable_hosts),
                  new PermissionSet());
   // TODO(rdevlin.cronin) We should notify the observers/renderer.
 }
 
+void PermissionsUpdater::ActivateGrantedHosts(
+    const Extension* extension) {
+  scoped_refptr<const PermissionSet> active =
+      extension->permissions_data()->active_permissions();
+  scoped_refptr<const PermissionSet> withheld =
+      extension->permissions_data()->withheld_permissions();
+
+  PermissionSet* granted = ExtensionPrefs::Get(browser_context_)
+      ->GetGrantedPermissions(extension->id());
+  URLPatternSet new_explicit_hosts(active->explicit_hosts());
+  URLPatternSet new_scriptable_hosts(active->scriptable_hosts());
+
+  for (URLPatternSet::const_iterator iter = granted->explicit_hosts().begin();
+       iter != granted->explicit_hosts().end();
+       ++iter) {
+    if (!iter->ImpliesAllHosts())
+      new_explicit_hosts.AddPattern(*iter);
+  }
+
+  for (URLPatternSet::const_iterator iter = granted->scriptable_hosts().begin();
+       iter != granted->scriptable_hosts().end();
+       ++iter) {
+    if (!iter->ImpliesAllHosts())
+      new_scriptable_hosts.AddPattern(*iter);
+  }
+
+  SetPermissions(extension,
+                 new PermissionSet(active->apis(),
+                                   active->manifest_permissions(),
+                                   new_explicit_hosts,
+                                   new_scriptable_hosts),
+                 withheld);

[gpdavis, 2014/08/07 20:50:39]

... ActivateGrantedHosts will crawl through the granted permissions and move
them to active if they dont imply all hosts.

Create new explicit and scriptable hosts URLPatternSets that are initialized
with the current active hosts.  Iterate through granted_permissions and copy any
permissions that are not all hosts into the new host permissions.  Then we
SetPermissions.

What do you think about this approach?  Is there any harm to adding all granted
permissions that aren't for all hosts?  This approach passes all the current
unittests.  If this is acceptable, I can go ahead and clean this patch up and
work on expanding the unit tests.

+}
+
 void PermissionsUpdater::SetPermissions(
     const Extension* extension,
     const scoped_refptr<const PermissionSet>& active,
     scoped_refptr<const PermissionSet> withheld) {
   withheld = withheld.get() ? withheld
                  : extension->permissions_data()->withheld_permissions();
   extension->permissions_data()->SetPermissions(active, withheld);
   ExtensionPrefs::Get(browser_context_)->SetActivePermissions(
       extension->id(), active.get());
 }
@@ skipping 58 matching lines @@
             Profile::FromBrowserContext(host->GetBrowserContext()))) {
       host->Send(new ExtensionMsg_UpdatePermissions(params));
     }
   }
 
   // Trigger the onAdded and onRemoved events in the extension.
   DispatchEvent(extension->id(), event_name, changed);
 }
 
 }  // namespace extensions