Lines Matching full:extension
59 #include "chrome/common/extensions/extension.h"
110 NEEDS_RELOCALIZATION, // The local has changed since we read this extension.
117 if (info.extension_location == Extension::LOAD)
163 // Loads a single extension from |path| where |path| is the top directory of
164 // a specific extension where its manifest file lives.
167 // TODO(erikkay): It might be useful to be able to load a packed extension
177 // Finish installing the extension in |crx_path| after it has been unpacked to
179 // extension's manifest before installation. If |silent| is true, there will
183 // Note: We take ownership of |extension|.
186 const Extension* extension,
189 // Notify the frontend that there was an error loading an extension.
228 int flags = Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD) ?
229 Extension::ALLOW_FILE_ACCESS : Extension::NO_FLAGS;
230 if (Extension::ShouldDoStrictErrorChecking(Extension::LOAD))
231 flags |= Extension::STRICT_ERROR_CHECKS;
233 scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
235 Extension::LOAD,
239 if (!extension) {
244 // Report this as an installed extension so that it gets remembered in the
250 extension));
267 // Check if the providers know about this extension.
273 return; // Yup, known extension, don't uninstall.
276 // This is an external extension that we don't have registered. Uninstall.
294 Extension::Location location) {
296 CHECK(Extension::IdIsValid(id));
299 // Already installed. Do not change the update URL that the extension set.
317 const Extension* download_extension = GetExtensionByWebExtent(download_url);
318 const Extension* referrer_extension = GetExtensionByWebExtent(referrer_url);
319 const Extension* webstore_app = GetWebStoreApp();
362 const Extension* ExtensionService::GetInstalledApp(const GURL& url) {
364 const Extension* app = GetExtensionByWebExtent(url);
382 // --uninstall-extension. The LOG statements within this function are used to
388 const Extension* extension =
390 if (!extension)
391 extension = extensions_service->GetTerminatedExtension(extension_id);
393 // We can't call UninstallExtension with an invalid extension ID.
394 if (!extension) {
395 LOG(WARNING) << "Attempted uninstallation of non-existent extension with "
401 // policy-controlled extension.
404 LOG(WARNING) << "Cannot uninstall extension with id " << extension_id
430 // Figure out if extension installation should be enabled.
529 const Extension* ExtensionService::GetExtensionById(
541 // the first extension, because its members listen for loaded notifications.
563 const Extension* extension = GetExtensionByIdInternal(id, true, true);
564 if (!is_pending_extension && !extension) {
565 LOG(WARNING) << "Will not update extension " << id
588 else if (extension)
589 installer->set_install_source(extension->location());
598 const Extension* current_extension = GetExtensionById(extension_id, false);
600 // Disable the extension if it's loaded. It might not be loaded if it crashed.
602 // If the extension has an inspector open for its background page, detach
631 // We should always be able to remember the extension's path. If it's not in
643 const Extension* extension =
645 if (!extension)
646 extension = GetTerminatedExtension(extension_id);
649 CHECK(extension);
651 // Get hold of information we need after unloading, since the extension
653 GURL extension_url(extension->url());
654 Extension::Location location(extension->location());
659 if (!Extension::UserMayDisable(location) && !external_uninstall) {
663 Details<const Extension>(extension));
670 UninstalledExtensionInfo uninstalled_extension_info(*extension);
673 extension->GetType(), 100);
675 extension, "Extensions.Permissions_Uninstall");
677 // Also copy the extension identifier since the reference might have been
678 // obtained via Extension::id().
682 profile_->GetTemplateURLModel()->UnregisterExtensionKeyword(extension);
692 if (Extension::LOAD != location) {
704 // Notify interested parties that we've uninstalled this extension.
722 // Extension::ENABLED by default; either change it to return
726 extension_prefs_->GetExtensionState(extension_id) == Extension::ENABLED;
737 const Extension* extension =
739 if (!extension)
742 extension_prefs_->SetExtensionState(extension, Extension::ENABLED);
745 extensions_.push_back(make_scoped_refptr(extension));
748 extension);
752 extension_prefs_->SetBrowserActionVisibility(extension, true);
755 extension->GetChromeURLOverrides());
757 NotifyExtensionLoaded(extension);
764 const Extension* extension =
766 // The extension may have been disabled already.
767 if (!extension)
770 if (!Extension::UserMayDisable(extension->location()))
773 extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
776 disabled_extensions_.push_back(make_scoped_refptr(extension));
779 extension);
783 extension->GetChromeURLOverrides());
785 NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::DISABLE);
789 void ExtensionService::GrantPermissions(const Extension* extension) {
790 CHECK(extension);
793 CHECK_EQ(Extension::INTERNAL, extension->location());
795 ExtensionExtent effective_hosts = extension->GetEffectiveHostPermissions();
796 extension_prefs_->AddGrantedPermissions(extension->id(),
797 extension->HasFullPermissions(),
798 extension->api_permissions(),
803 const Extension* extension) {
804 CHECK(extension);
806 extension, "Extensions.Permissions_ReEnable");
807 GrantPermissions(extension);
808 extension_prefs_->SetDidExtensionEscalatePermissions(extension, false);
809 EnableExtension(extension->id());
829 const Extension* ExtensionService::LoadComponentExtension(
834 DLOG(ERROR) << "Failed to parse manifest for extension";
838 int flags = Extension::REQUIRE_KEY;
839 if (Extension::ShouldDoStrictErrorChecking(Extension::COMPONENT))
840 flags |= Extension::STRICT_ERROR_CHECKS;
842 scoped_refptr<const Extension> extension(Extension::Create(
844 Extension::COMPONENT,
848 if (!extension.get()) {
852 AddExtension(extension);
853 return extension;
880 // Reloading and extension reads files from disk. We do this on the
888 int flags = Extension::NO_FLAGS;
889 if (Extension::ShouldDoStrictErrorChecking(info->extension_location))
890 flags |= Extension::STRICT_ERROR_CHECKS;
892 flags |= Extension::ALLOW_FILE_ACCESS;
894 scoped_refptr<const Extension> extension(
901 if (extension.get()) {
904 extension->manifest_value()->DeepCopy()));
942 Extension::Location location = (*ex)->location();
943 Extension::Type type = (*ex)->GetType();
947 } else if (type == Extension::TYPE_EXTENSION) {
954 if (location == Extension::COMPONENT)
959 if (location == Extension::LOAD)
967 case Extension::TYPE_THEME:
970 case Extension::TYPE_USER_SCRIPT:
973 case Extension::TYPE_HOSTED_APP:
977 case Extension::TYPE_PACKAGED_APP:
981 case Extension::TYPE_EXTENSION:
986 if (Extension::IsExternalLocation(location))
1010 const Extension* e, const char* histogram) {
1016 Extension::PermissionMessage::ID_ENUM_BOUNDARY,
1017 Extension::PermissionMessage::ID_ENUM_BOUNDARY + 1,
1020 std::vector<Extension::PermissionMessage> permissions =
1023 counter->Add(Extension::PermissionMessage::ID_NONE);
1025 std::vector<Extension::PermissionMessage>::iterator it;
1034 scoped_refptr<const Extension> extension(NULL);
1038 int flags = Extension::NO_FLAGS;
1039 if (info.extension_location != Extension::LOAD)
1040 flags |= Extension::REQUIRE_KEY;
1041 if (Extension::ShouldDoStrictErrorChecking(info.extension_location))
1042 flags |= Extension::STRICT_ERROR_CHECKS;
1044 flags |= Extension::ALLOW_FILE_ACCESS;
1045 extension = Extension::Create(
1055 if (!extension) {
1064 extension_prefs_->UpdateManifest(extension);
1066 AddExtension(extension);
1069 void ExtensionService::NotifyExtensionLoaded(const Extension* extension) {
1070 // The ChromeURLRequestContexts need to be first to know that the extension
1072 // for the extension may try to load an extension URL with an extension id
1075 // extension.
1077 profile_->RegisterExtensionWithRequestContexts(extension);
1079 GrantRightsForExtension(extension);
1085 Details<const Extension>(extension));
1088 for (size_t i = 0; i < extension->plugins().size(); ++i) {
1089 const Extension::PluginInfo& plugin = extension->plugins()[i];
1095 plugin.path, extension->url());
1100 for (size_t i = 0; i < extension->nacl_modules().size(); ++i) {
1101 const Extension::NaClModuleInfo& module = extension->nacl_modules()[i];
1114 const Extension* extension, UnloadedExtensionInfo::Reason reason) {
1115 UnloadedExtensionInfo details(extension, reason);
1122 profile_->UnregisterExtensionWithRequestContexts(extension->id(), reason);
1124 RevokeRightsForExtension(extension);
1131 RevokeAccessForExtension(extension->id());
1137 for (size_t i = 0; i < extension->plugins().size(); ++i) {
1138 const Extension::PluginInfo& plugin = extension->plugins()[i];
1151 for (size_t i = 0; i < extension->nacl_modules().size(); ++i) {
1152 const Extension::NaClModuleInfo& module = extension->nacl_modules()[i];
1166 // Use this set to indicate if an extension in the blacklist has been used.
1169 if (Extension::IdIsValid(blacklist[i])) {
1178 const Extension* extension = (*iter);
1179 if (blacklist_set.find(extension->id()) != blacklist_set.end()) {
1180 to_be_removed.push_back(extension->id());
1219 const Extension* extension = (*iter);
1220 if (!extension_prefs_->IsExtensionAllowedByPolicy(extension->id()))
1221 to_be_removed.push_back(extension->id());
1247 LOG(WARNING) << "Could not uninstall extension " << id
1253 const Extension* extension = GetExtensionByIdInternal(id, true, true);
1259 // extension regardless of whether or not it's installed (and have
1261 if (extension) {
1268 int result = extension->version()->CompareTo(extension_sync_data.version);
1270 // Extension is outdated.
1297 // If this is an existing component extension we always allow it to
1299 const Extension* extension = GetExtensionById(extension_id, true);
1300 if (extension && extension->location() == Extension::COMPONENT)
1309 const Extension* extension = GetExtensionById(extension_id, false);
1310 if (extension && extension->location() == Extension::COMPONENT) {
1317 // if the value changed and the extension is actually enabled, since there is
1324 if (extension) {
1325 NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::DISABLE);
1326 NotifyExtensionLoaded(extension);
1330 bool ExtensionService::CanCrossIncognito(const Extension* extension) {
1331 // We allow the extension to see events and data from another profile iff it
1334 return IsIncognitoEnabled(extension->id()) &&
1335 !extension->incognito_split_mode();
1338 bool ExtensionService::AllowFileAccess(const Extension* extension) {
1341 extension_prefs_->AllowFileAccess(extension->id()));
1344 void ExtensionService::SetAllowFileAccess(const Extension* extension,
1347 // extension is actually enabled, since there is no UI otherwise.
1348 bool old_allow = AllowFileAccess(extension);
1352 extension_prefs_->SetAllowFileAccess(extension->id(), allow);
1355 extension) != extensions_.end();
1357 ReloadExtension(extension->id());
1360 bool ExtensionService::GetBrowserActionVisibility(const Extension* extension) {
1361 return extension_prefs_->GetBrowserActionVisibility(extension);
1364 void ExtensionService::SetBrowserActionVisibility(const Extension* extension,
1366 extension_prefs_->SetBrowserActionVisibility(extension, visible);
1371 // these, the extension will register its location in the the preferences file
1384 // they could install an extension manually themselves anyway.
1386 // If any external extension records give a URL, a provider will set
1388 // to start an update check to fetch a new external extension.
1391 // Ask each external extension provider to give us a call back for each
1392 // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
1433 if (Extension::IsExternalLocation(info->extension_location))
1441 // Make sure the extension gets deleted after we return from this function.
1442 scoped_refptr<const Extension> extension(
1445 // This method can be called via PostTask, so the extension may have been
1447 if (!extension) {
1448 // In case the extension may have crashed/uninstalled. Allow the profile to
1454 // Keep information about the extension so that we can reload it later
1456 unloaded_extension_paths_[extension->id()] = extension->path();
1458 // Clean up if the extension is meant to be enabled after a reload.
1459 disabled_extension_paths_.erase(extension->id());
1465 extension->GetChromeURLOverrides());
1469 extension.get());
1471 UnloadedExtensionInfo details(extension, reason);
1479 // disabled extension is unloaded (since they are also tracking the disabled
1485 iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
1487 // Remove the extension from our list.
1490 NotifyExtensionUnloaded(extension.get(), reason);
1506 // EXTENSION_UNLOADED since that implies that the extension has been disabled
1552 void ExtensionService::AddExtension(const Extension* extension) {
1553 // Ensure extension is deleted unless we transfer ownership.
1554 scoped_refptr<const Extension> scoped_extension(extension);
1556 // The extension is now loaded, remove its data from unloaded extension map.
1557 unloaded_extension_paths_.erase(extension->id());
1559 // If a terminated extension is loaded, remove it from the terminated list.
1560 UntrackTerminatedExtension(extension->id());
1562 // If the extension was disabled for a reload, then enable it.
1563 if (disabled_extension_paths_.erase(extension->id()) > 0)
1564 EnableExtension(extension->id());
1567 // default extension state to DISABLED when the --disable-extensions flag
1570 !extension->is_theme() &&
1571 extension->location() != Extension::COMPONENT &&
1572 !Extension::IsExternalLocation(extension->location()))
1575 // Check if the extension's privileges have changed and disable the
1576 // extension if necessary.
1577 DisableIfPrivilegeIncrease(extension);
1579 switch (extension_prefs_->GetExtensionState(extension->id())) {
1580 case Extension::ENABLED:
1583 NotifyExtensionLoaded(extension);
1586 profile_, extension->GetChromeURLOverrides());
1588 case Extension::DISABLED:
1593 Details<const Extension>(extension));
1600 SetBeingUpgraded(extension, false);
1605 profile_->GetTemplateURLModel()->RegisterExtensionKeyword(extension);
1609 if (!extension->omnibox_keyword().empty()) {
1610 omnibox_popup_icon_manager_.LoadIcon(extension);
1611 omnibox_icon_manager_.LoadIcon(extension);
1615 void ExtensionService::DisableIfPrivilegeIncrease(const Extension* extension) {
1616 // We keep track of all permissions the user has granted each extension.
1619 // installs the extension, only the recognized permissions are recorded.
1626 // for an API that adds suggestions to the omnibox. An extension can
1628 // manifest. If a user installs the extension on Chrome 9, the browser
1631 // will disable the extension and prompt the user to approve the increase
1632 // in privileges. The extension could then release a new version that
1635 // extension once again includes "omnibox" in an upgrade, the extension
1637 const Extension* old = GetExtensionByIdInternal(extension->id(),
1648 if (extension->location() == Extension::INTERNAL) {
1651 if (!extension_prefs_->GetGrantedPermissions(extension->id(),
1655 GrantPermissions(extension);
1656 CHECK(extension_prefs_->GetGrantedPermissions(extension->id(),
1662 // Here, we check if an extension's privileges have increased in a manner
1664 // upgraded and recognized additional privileges, or an extension upgrades
1666 is_privilege_increase = Extension::IsPrivilegeIncrease(
1667 granted_full_access, granted_apis, granted_extent, extension);
1673 if (extension->location() != Extension::LOAD)
1674 CHECK(extension->version()->CompareTo(*(old->version())) >= 0);
1680 SetBeingUpgraded(extension, true);
1683 // To upgrade an extension in place, unload the old one and
1689 // Extension has changed permissions significantly. Disable it. A
1692 if (!extension_prefs_->DidExtensionEscalatePermissions(extension->id())) {
1694 extension, "Extensions.Permissions_AutoDisable");
1696 extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
1697 extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
1705 extensions_[i]->location() != Extension::COMPONENT)
1712 void ExtensionService::OnExtensionInstalled(const Extension* extension) {
1715 // Ensure extension is deleted unless we transfer ownership.
1716 scoped_refptr<const Extension> scoped_extension(extension);
1717 const std::string& id = extension->id();
1725 if (!pending_extension_info.ShouldAllowInstall(*extension)) {
1728 << id << " of type " << extension->GetType()
1729 << " and update URL " << extension->update_url().spec()
1735 Details<const Extension>(extension));
1737 // Delete the extension directory since we're not going to
1742 extension->path(), true));
1746 if (extension->is_theme()) {
1758 // extension; if we're here, that means the user is manually
1759 // installing the extension.
1766 extension->GetType(), 100);
1768 extension, "Extensions.Permissions_Install");
1769 ShownSectionsHandler::OnExtensionInstalled(profile_->GetPrefs(), extension);
1771 extension, initial_enable ? Extension::ENABLED : Extension::DISABLED,
1776 if (Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD) &&
1784 Details<const Extension>(extension));
1786 // Transfer ownership of |extension| to AddExtension.
1790 const Extension* ExtensionService::GetExtensionByIdInternal(
1810 void ExtensionService::TrackTerminatedExtension(const Extension* extension) {
1811 if (terminated_extension_ids_.insert(extension->id()).second)
1812 terminated_extensions_.push_back(make_scoped_refptr(extension));
1829 const Extension* ExtensionService::GetTerminatedExtension(
1840 const Extension* ExtensionService::GetWebStoreApp() {
1844 const Extension* ExtensionService::GetExtensionByURL(const GURL& url) {
1849 const Extension* ExtensionService::GetExtensionByWebExtent(const GURL& url) {
1858 // Allow bindings for all packaged extension.
1863 const Extension* extension = GetExtensionByWebExtent(url);
1864 return (extension && extension->location() == Extension::COMPONENT);
1867 const Extension* ExtensionService::GetExtensionByOverlappingWebExtent(
1891 Extension::Location location) {
1893 CHECK(Extension::IdIsValid(id));
1902 const Extension* existing = GetExtensionById(id, true);
1910 LOG(WARNING) << "Found external version of extension " << id
1941 "Could not load extension from '%s'. %s",
1967 TrackTerminatedExtension(host->extension());
1969 // Unload the entire extension. We want it to be in a consistent state:
1972 // still have access to the Extension and ExtensionHost.
1976 host->extension()->id(),
2005 if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
2012 bool ExtensionService::IsBackgroundPageReady(const Extension* extension) {
2013 return (extension->background_url().is_empty() ||
2014 extension_runtime_data_[extension->id()].background_page_ready);
2017 void ExtensionService::SetBackgroundPageReady(const Extension* extension) {
2018 DCHECK(!extension->background_url().is_empty());
2019 extension_runtime_data_[extension->id()].background_page_ready = true;
2022 Source<const Extension>(extension),
2026 bool ExtensionService::IsBeingUpgraded(const Extension* extension) {
2027 return extension_runtime_data_[extension->id()].being_upgraded;
2030 void ExtensionService::SetBeingUpgraded(const Extension* extension,
2032 extension_runtime_data_[extension->id()].being_upgraded = value;
2035 PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
2036 return &extension_runtime_data_[extension->id()].property_bag;
