Create withheld permissions

chrome/browser/extensions/extension_util.cc

 // Copyright 2013 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_util.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sync_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
 #include "chrome/common/extensions/sync_helper.h"
 #include "content/public/browser/site_instance.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
+#include "extensions/common/permissions/permissions_data.h"
 #include "grit/theme_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace extensions {
 namespace util {
 
 namespace {
 // The entry into the ExtensionPrefs for allowing an extension to script on
 // all urls without explicit permission.
 const char kExtensionAllowedOnAllUrlsPrefName[] =
@@ skipping 139 matching lines @@
   return ExtensionPrefs::Get(context)->ReadPrefAsBoolean(
              extension_id,
              kExtensionAllowedOnAllUrlsPrefName,
              &allowed) &&
          allowed;
 }
 
 void SetAllowedScriptingOnAllUrls(const std::string& extension_id,
                                   content::BrowserContext* context,
                                   bool allowed) {
+  if (allowed == AllowedScriptingOnAllUrls(extension_id, context))
+    return;  // Nothing to do here.
+
   ExtensionPrefs::Get(context)->UpdateExtensionPref(
       extension_id,
       kExtensionAllowedOnAllUrlsPrefName,
       allowed ? new base::FundamentalValue(true) : NULL);
+
+  const Extension* extension =
+      ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
+          extension_id);
+  if (extension) {
+    if (allowed)
+      extension->permissions_data()->GrantWithheldAllHosts();

[not at google - send to devlin, 2014/06/30 14:37:03]

- what about on browser startup (I can't see an obvious place where this is
happening)?
- what about on the renderer?

[Devlin, 2014/06/30 17:06:10]

Whoops.  Had that in there at some point, but it must have fallen out in a
refactor.

So, here's the flow:
On startup, we load extensions.
On extension load, we update the permissions to include what's in the manifest,
prefs, etc.  This is the call to PermissionsUpdater::InitializePermissions()
from ExtensionService.
On InitializePermissions, we initialize permissions (now including this!).
This is the first time we initialize any permissions, so anytime we update
permissions or send them to the renderer, it will be included.

+    else
+      extension->permissions_data()->WithholdAllHosts();
+  }
 }
 
 bool IsAppLaunchable(const std::string& extension_id,
                      content::BrowserContext* context) {
   int reason = ExtensionPrefs::Get(context)->GetDisableReasons(extension_id);
   return !((reason & Extension::DISABLE_UNSUPPORTED_REQUIREMENT) ||
            (reason & Extension::DISABLE_CORRUPTED));
 }
 
 bool IsAppLaunchableWithoutEnabling(const std::string& extension_id,
@@ skipping 89 matching lines @@
       IDR_APP_DEFAULT_ICON);
 }
 
 const gfx::ImageSkia& GetDefaultExtensionIcon() {
   return *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
       IDR_EXTENSION_DEFAULT_ICON);
 }
 
 }  // namespace util
 }  // namespace extensions