Home | History | Annotate | Download | only in extensions 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/extensions/extension_util.h"
      6 
      7 #include "base/command_line.h"
      8 #include "base/logging.h"
      9 #include "base/values.h"
     10 #include "chrome/browser/extensions/extension_service.h"
     11 #include "chrome/browser/extensions/extension_sync_service.h"
     12 #include "chrome/browser/extensions/permissions_updater.h"
     13 #include "chrome/browser/profiles/profile.h"
     14 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
     15 #include "chrome/common/chrome_switches.h"
     16 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
     17 #include "chrome/common/extensions/sync_helper.h"
     18 #include "content/public/browser/site_instance.h"
     19 #include "extensions/browser/extension_prefs.h"
     20 #include "extensions/browser/extension_registry.h"
     21 #include "extensions/browser/extension_system.h"
     22 #include "extensions/browser/extension_util.h"
     23 #include "extensions/common/extension.h"
     24 #include "extensions/common/extension_icon_set.h"
     25 #include "extensions/common/feature_switch.h"
     26 #include "extensions/common/features/simple_feature.h"
     27 #include "extensions/common/manifest.h"
     28 #include "extensions/common/manifest_handlers/incognito_info.h"
     29 #include "extensions/common/permissions/permissions_data.h"
     30 #include "extensions/grit/extensions_browser_resources.h"
     31 #include "ui/base/resource/resource_bundle.h"
     32 
     33 namespace extensions {
     34 namespace util {
     35 
     36 namespace {
     37 
     38 // The entry into the ExtensionPrefs for allowing an extension to script on
     39 // all urls without explicit permission.
     40 const char kExtensionAllowedOnAllUrlsPrefName[] =
     41     "extension_can_script_all_urls";
     42 
     43 // Returns true if |extension_id| for an external component extension should
     44 // always be enabled in incognito windows.
     45 bool IsWhitelistedForIncognito(const std::string& extension_id) {
     46   static const char* kExtensionWhitelist[] = {
     47     "D5736E4B5CF695CB93A2FB57E4FDC6E5AFAB6FE2",  // http://crbug.com/312900
     48     "D57DE394F36DC1C3220E7604C575D29C51A6C495",  // http://crbug.com/319444
     49     "3F65507A3B39259B38C8173C6FFA3D12DF64CCE9"   // http://crbug.com/371562
     50   };
     51 
     52   return extensions::SimpleFeature::IsIdInList(
     53       extension_id,
     54       std::set<std::string>(
     55           kExtensionWhitelist,
     56           kExtensionWhitelist + arraysize(kExtensionWhitelist)));
     57 }
     58 
     59 // Returns |extension_id|. See note below.
     60 std::string ReloadExtensionIfEnabled(const std::string& extension_id,
     61                                      content::BrowserContext* context) {
     62   ExtensionRegistry* registry = ExtensionRegistry::Get(context);
     63   bool extension_is_enabled =
     64       registry->enabled_extensions().Contains(extension_id);
     65 
     66   if (!extension_is_enabled)
     67     return extension_id;
     68 
     69   // When we reload the extension the ID may be invalidated if we've passed it
     70   // by const ref everywhere. Make a copy to be safe. http://crbug.com/103762
     71   std::string id = extension_id;
     72   ExtensionService* service =
     73       ExtensionSystem::Get(context)->extension_service();
     74   CHECK(service);
     75   service->ReloadExtension(id);
     76   return id;
     77 }
     78 
     79 }  // namespace
     80 
     81 bool IsIncognitoEnabled(const std::string& extension_id,
     82                         content::BrowserContext* context) {
     83   const Extension* extension = ExtensionRegistry::Get(context)->
     84       GetExtensionById(extension_id, ExtensionRegistry::ENABLED);
     85   if (extension) {
     86     if (!extension->can_be_incognito_enabled())
     87       return false;
     88     // If this is an existing component extension we always allow it to
     89     // work in incognito mode.
     90     if (extension->location() == Manifest::COMPONENT)
     91       return true;
     92     if (extension->location() == Manifest::EXTERNAL_COMPONENT &&
     93         IsWhitelistedForIncognito(extension_id)) {
     94       return true;
     95     }
     96   }
     97 
     98   return ExtensionPrefs::Get(context)->IsIncognitoEnabled(extension_id);
     99 }
    100 
    101 void SetIsIncognitoEnabled(const std::string& extension_id,
    102                            content::BrowserContext* context,
    103                            bool enabled) {
    104   ExtensionRegistry* registry = ExtensionRegistry::Get(context);
    105   const Extension* extension =
    106       registry->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
    107 
    108   if (extension) {
    109     if (!extension->can_be_incognito_enabled())
    110       return;
    111 
    112     if (extension->location() == Manifest::COMPONENT) {
    113       // This shouldn't be called for component extensions unless it is called
    114       // by sync, for syncable component extensions.
    115       // See http://crbug.com/112290 and associated CLs for the sordid history.
    116       DCHECK(sync_helper::IsSyncable(extension));
    117 
    118       // If we are here, make sure the we aren't trying to change the value.
    119       DCHECK_EQ(enabled, IsIncognitoEnabled(extension_id, context));
    120       return;
    121     }
    122   }
    123 
    124   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(context);
    125   // Broadcast unloaded and loaded events to update browser state. Only bother
    126   // if the value changed and the extension is actually enabled, since there is
    127   // no UI otherwise.
    128   bool old_enabled = extension_prefs->IsIncognitoEnabled(extension_id);
    129   if (enabled == old_enabled)
    130     return;
    131 
    132   extension_prefs->SetIsIncognitoEnabled(extension_id, enabled);
    133 
    134   std::string id = ReloadExtensionIfEnabled(extension_id, context);
    135 
    136   // Reloading the extension invalidates the |extension| pointer.
    137   extension = registry->GetExtensionById(id, ExtensionRegistry::EVERYTHING);
    138   if (extension) {
    139     Profile* profile = Profile::FromBrowserContext(context);
    140     ExtensionSyncService::Get(profile)->SyncExtensionChangeIfNeeded(*extension);
    141   }
    142 }
    143 
    144 bool CanCrossIncognito(const Extension* extension,
    145                        content::BrowserContext* context) {
    146   // We allow the extension to see events and data from another profile iff it
    147   // uses "spanning" behavior and it has incognito access. "split" mode
    148   // extensions only see events for a matching profile.
    149   CHECK(extension);
    150   return IsIncognitoEnabled(extension->id(), context) &&
    151          !IncognitoInfo::IsSplitMode(extension);
    152 }
    153 
    154 bool CanLoadInIncognito(const Extension* extension,
    155                         content::BrowserContext* context) {
    156   CHECK(extension);
    157   if (extension->is_hosted_app())
    158     return true;
    159   // Packaged apps and regular extensions need to be enabled specifically for
    160   // incognito (and split mode should be set).
    161   return IncognitoInfo::IsSplitMode(extension) &&
    162          IsIncognitoEnabled(extension->id(), context);
    163 }
    164 
    165 bool AllowFileAccess(const std::string& extension_id,
    166                      content::BrowserContext* context) {
    167   return CommandLine::ForCurrentProcess()->HasSwitch(
    168              switches::kDisableExtensionsFileAccessCheck) ||
    169          ExtensionPrefs::Get(context)->AllowFileAccess(extension_id);
    170 }
    171 
    172 void SetAllowFileAccess(const std::string& extension_id,
    173                         content::BrowserContext* context,
    174                         bool allow) {
    175   // Reload to update browser state. Only bother if the value changed and the
    176   // extension is actually enabled, since there is no UI otherwise.
    177   if (allow == AllowFileAccess(extension_id, context))
    178     return;
    179 
    180   ExtensionPrefs::Get(context)->SetAllowFileAccess(extension_id, allow);
    181 
    182   ReloadExtensionIfEnabled(extension_id, context);
    183 }
    184 
    185 bool AllowedScriptingOnAllUrls(const std::string& extension_id,
    186                                content::BrowserContext* context) {
    187   bool allowed = false;
    188   return ExtensionPrefs::Get(context)->ReadPrefAsBoolean(
    189              extension_id,
    190              kExtensionAllowedOnAllUrlsPrefName,
    191              &allowed) &&
    192          allowed;
    193 }
    194 
    195 void SetAllowedScriptingOnAllUrls(const std::string& extension_id,
    196                                   content::BrowserContext* context,
    197                                   bool allowed) {
    198   if (allowed == AllowedScriptingOnAllUrls(extension_id, context))
    199     return;  // Nothing to do here.
    200 
    201   ExtensionPrefs::Get(context)->UpdateExtensionPref(
    202       extension_id,
    203       kExtensionAllowedOnAllUrlsPrefName,
    204       allowed ? new base::FundamentalValue(true) : NULL);
    205 
    206   const Extension* extension =
    207       ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
    208           extension_id);
    209   if (extension) {
    210     PermissionsUpdater updater(context);
    211     if (allowed)
    212       updater.GrantWithheldImpliedAllHosts(extension);
    213     else
    214       updater.WithholdImpliedAllHosts(extension);
    215   }
    216 }
    217 
    218 bool ScriptsMayRequireActionForExtension(const Extension* extension) {
    219   // An extension requires user action to execute scripts iff the switch to do
    220   // so is enabled, the extension shows up in chrome:extensions (so the user can
    221   // grant withheld permissions), the extension is not part of chrome or
    222   // corporate policy, and also not on the scripting whitelist.
    223   return FeatureSwitch::scripts_require_action()->IsEnabled() &&
    224       extension->ShouldDisplayInExtensionSettings() &&
    225       !Manifest::IsPolicyLocation(extension->location()) &&
    226       !Manifest::IsComponentLocation(extension->location()) &&
    227       !PermissionsData::CanExecuteScriptEverywhere(extension);
    228 }
    229 
    230 bool IsAppLaunchable(const std::string& extension_id,
    231                      content::BrowserContext* context) {
    232   int reason = ExtensionPrefs::Get(context)->GetDisableReasons(extension_id);
    233   return !((reason & Extension::DISABLE_UNSUPPORTED_REQUIREMENT) ||
    234            (reason & Extension::DISABLE_CORRUPTED));
    235 }
    236 
    237 bool IsAppLaunchableWithoutEnabling(const std::string& extension_id,
    238                                     content::BrowserContext* context) {
    239   return ExtensionRegistry::Get(context)->GetExtensionById(
    240       extension_id, ExtensionRegistry::ENABLED) != NULL;
    241 }
    242 
    243 bool ShouldSyncExtension(const Extension* extension,
    244                          content::BrowserContext* context) {
    245   return sync_helper::IsSyncableExtension(extension) &&
    246          !ExtensionPrefs::Get(context)->DoNotSync(extension->id());
    247 }
    248 
    249 bool ShouldSyncApp(const Extension* app, content::BrowserContext* context) {
    250   return sync_helper::IsSyncableApp(app) &&
    251          !util::IsEphemeralApp(app->id(), context) &&
    252          !ExtensionPrefs::Get(context)->DoNotSync(app->id());
    253 }
    254 
    255 bool IsExtensionIdle(const std::string& extension_id,
    256                      content::BrowserContext* context) {
    257   ProcessManager* process_manager =
    258       ExtensionSystem::Get(context)->process_manager();
    259   DCHECK(process_manager);
    260   ExtensionHost* host =
    261       process_manager->GetBackgroundHostForExtension(extension_id);
    262   if (host)
    263     return false;
    264 
    265   content::SiteInstance* site_instance = process_manager->GetSiteInstanceForURL(
    266       Extension::GetBaseURLFromExtensionId(extension_id));
    267   if (site_instance && site_instance->HasProcess())
    268     return false;
    269 
    270   return process_manager->GetRenderViewHostsForExtension(extension_id).empty();
    271 }
    272 
    273 GURL GetSiteForExtensionId(const std::string& extension_id,
    274                            content::BrowserContext* context) {
    275   return content::SiteInstance::GetSiteForURL(
    276       context, Extension::GetBaseURLFromExtensionId(extension_id));
    277 }
    278 
    279 scoped_ptr<base::DictionaryValue> GetExtensionInfo(const Extension* extension) {
    280   DCHECK(extension);
    281   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
    282 
    283   dict->SetString("id", extension->id());
    284   dict->SetString("name", extension->name());
    285 
    286   GURL icon = extensions::ExtensionIconSource::GetIconURL(
    287       extension,
    288       extension_misc::EXTENSION_ICON_SMALLISH,
    289       ExtensionIconSet::MATCH_BIGGER,
    290       false,  // Not grayscale.
    291       NULL);  // Don't set bool if exists.
    292   dict->SetString("icon", icon.spec());
    293 
    294   return dict.Pass();
    295 }
    296 
    297 bool HasIsolatedStorage(const ExtensionInfo& info) {
    298   if (!info.extension_manifest.get())
    299     return false;
    300 
    301   std::string error;
    302   scoped_refptr<const Extension> extension(Extension::Create(
    303       info.extension_path,
    304       info.extension_location,
    305       *info.extension_manifest,
    306       Extension::NO_FLAGS,
    307       info.extension_id,
    308       &error));
    309   if (!extension.get())
    310     return false;
    311 
    312   return AppIsolationInfo::HasIsolatedStorage(extension.get());
    313 }
    314 
    315 bool SiteHasIsolatedStorage(const GURL& extension_site_url,
    316                             content::BrowserContext* context) {
    317   const Extension* extension = ExtensionRegistry::Get(context)->
    318       enabled_extensions().GetExtensionOrAppByURL(extension_site_url);
    319   if (!extension)
    320     return false;
    321 
    322   return AppIsolationInfo::HasIsolatedStorage(extension);
    323 }
    324 
    325 const gfx::ImageSkia& GetDefaultAppIcon() {
    326   return *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
    327       IDR_APP_DEFAULT_ICON);
    328 }
    329 
    330 const gfx::ImageSkia& GetDefaultExtensionIcon() {
    331   return *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
    332       IDR_EXTENSION_DEFAULT_ICON);
    333 }
    334 
    335 bool IsStreamlinedHostedAppsEnabled() {
    336   return CommandLine::ForCurrentProcess()->HasSwitch(
    337           switches::kEnableStreamlinedHostedApps);
    338 }
    339 
    340 }  // namespace util
    341 }  // namespace extensions
    342