blob: ee61be99148f93dd989c94b9f2205dc536f742c0 [file] [log] [blame]
// Copyright 2014 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_system_impl.h"
#include "base/base_switches.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/field_trial.h"
#include "base/strings/string_tokenizer.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/content_settings/cookie_settings.h"
#include "chrome/browser/extensions/blacklist.h"
#include "chrome/browser/extensions/component_loader.h"
#include "chrome/browser/extensions/error_console/error_console.h"
#include "chrome/browser/extensions/extension_error_reporter.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/extensions/extension_system_factory.h"
#include "chrome/browser/extensions/extension_util.h"
#include "chrome/browser/extensions/extension_warning_badge_service.h"
#include "chrome/browser/extensions/extension_warning_set.h"
#include "chrome/browser/extensions/install_verifier.h"
#include "chrome/browser/extensions/navigation_observer.h"
#include "chrome/browser/extensions/shared_module_service.h"
#include "chrome/browser/extensions/standard_management_policy_provider.h"
#include "chrome/browser/extensions/updater/manifest_fetch_data.h"
#include "chrome/browser/extensions/user_script_master.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/chrome_version_info.h"
#include "chrome/common/extensions/extension_constants.h"
#include "chrome/common/extensions/extension_file_util.h"
#include "chrome/common/extensions/features/feature_channel.h"
#include "chrome/common/extensions/manifest_url_handler.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/url_data_source.h"
#include "extensions/browser/content_verifier.h"
#include "extensions/browser/content_verifier_delegate.h"
#include "extensions/browser/event_router.h"
#include "extensions/browser/extension_pref_store.h"
#include "extensions/browser/extension_pref_value_map.h"
#include "extensions/browser/extension_pref_value_map_factory.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/info_map.h"
#include "extensions/browser/lazy_background_task_queue.h"
#include "extensions/browser/management_policy.h"
#include "extensions/browser/process_manager.h"
#include "extensions/browser/quota_service.h"
#include "extensions/browser/runtime_data.h"
#include "extensions/browser/state_store.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension.h"
#include "extensions/common/manifest.h"
#include "net/base/escape.h"
#if defined(ENABLE_EXTENSIONS)
#include "chrome/browser/extensions/unpacked_installer.h"
#include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
#endif
#if defined(ENABLE_NOTIFICATIONS)
#include "chrome/browser/notifications/desktop_notification_service.h"
#include "chrome/browser/notifications/desktop_notification_service_factory.h"
#include "ui/message_center/notifier_settings.h"
#endif
#if defined(OS_CHROMEOS)
#include "chrome/browser/app_mode/app_mode_utils.h"
#include "chrome/browser/chromeos/extensions/device_local_account_management_policy_provider.h"
#include "chrome/browser/chromeos/login/users/user.h"
#include "chrome/browser/chromeos/login/users/user_manager.h"
#include "chrome/browser/chromeos/policy/device_local_account.h"
#include "chrome/browser/extensions/extension_assets_manager_chromeos.h"
#include "chromeos/chromeos_switches.h"
#include "chromeos/login/login_state.h"
#endif
using content::BrowserThread;
namespace {
const char kContentVerificationExperimentName[] =
"ExtensionContentVerification";
} // namespace
namespace extensions {
//
// ExtensionSystemImpl::Shared
//
ExtensionSystemImpl::Shared::Shared(Profile* profile)
: profile_(profile) {
}
ExtensionSystemImpl::Shared::~Shared() {
}
void ExtensionSystemImpl::Shared::InitPrefs() {
lazy_background_task_queue_.reset(new LazyBackgroundTaskQueue(profile_));
event_router_.reset(new EventRouter(profile_, ExtensionPrefs::Get(profile_)));
// TODO(yoz): Remove once crbug.com/159265 is fixed.
#if defined(ENABLE_EXTENSIONS)
// Two state stores. The latter, which contains declarative rules, must be
// loaded immediately so that the rules are ready before we issue network
// requests.
state_store_.reset(new StateStore(
profile_,
profile_->GetPath().AppendASCII(extensions::kStateStoreName),
true));
rules_store_.reset(new StateStore(
profile_,
profile_->GetPath().AppendASCII(extensions::kRulesStoreName),
false));
blacklist_.reset(new Blacklist(ExtensionPrefs::Get(profile_)));
standard_management_policy_provider_.reset(
new StandardManagementPolicyProvider(ExtensionPrefs::Get(profile_)));
#if defined (OS_CHROMEOS)
const chromeos::User* user = chromeos::UserManager::Get()->GetActiveUser();
policy::DeviceLocalAccount::Type device_local_account_type;
if (user && policy::IsDeviceLocalAccountUser(user->email(),
&device_local_account_type)) {
device_local_account_management_policy_provider_.reset(
new chromeos::DeviceLocalAccountManagementPolicyProvider(
device_local_account_type));
}
#endif // defined (OS_CHROMEOS)
#endif // defined(ENABLE_EXTENSIONS)
}
void ExtensionSystemImpl::Shared::RegisterManagementPolicyProviders() {
// TODO(yoz): Remove once crbug.com/159265 is fixed.
#if defined(ENABLE_EXTENSIONS)
DCHECK(standard_management_policy_provider_.get());
management_policy_->RegisterProvider(
standard_management_policy_provider_.get());
#if defined (OS_CHROMEOS)
if (device_local_account_management_policy_provider_) {
management_policy_->RegisterProvider(
device_local_account_management_policy_provider_.get());
}
#endif // defined (OS_CHROMEOS)
management_policy_->RegisterProvider(install_verifier_.get());
#endif // defined(ENABLE_EXTENSIONS)
}
namespace {
class ContentVerifierDelegateImpl : public ContentVerifierDelegate {
public:
explicit ContentVerifierDelegateImpl(ExtensionService* service)
: service_(service->AsWeakPtr()), default_mode_(GetDefaultMode()) {}
virtual ~ContentVerifierDelegateImpl() {}
virtual Mode ShouldBeVerified(const Extension& extension) OVERRIDE {
#if defined(OS_CHROMEOS)
if (ExtensionAssetsManagerChromeOS::IsSharedInstall(&extension))
return ContentVerifierDelegate::ENFORCE_STRICT;
#endif
if (!extension.is_extension() && !extension.is_legacy_packaged_app())
return ContentVerifierDelegate::NONE;
if (!Manifest::IsAutoUpdateableLocation(extension.location()))
return ContentVerifierDelegate::NONE;
if (!ManifestURL::UpdatesFromGallery(&extension)) {
// It's possible that the webstore update url was overridden for testing
// so also consider extensions with the default (production) update url
// to be from the store as well.
GURL default_webstore_url = extension_urls::GetDefaultWebstoreUpdateUrl();
if (ManifestURL::GetUpdateURL(&extension) != default_webstore_url)
return ContentVerifierDelegate::NONE;
}
return default_mode_;
}
virtual const ContentVerifierKey& PublicKey() OVERRIDE {
static ContentVerifierKey key(
extension_misc::kWebstoreSignaturesPublicKey,
extension_misc::kWebstoreSignaturesPublicKeySize);
return key;
}
virtual GURL GetSignatureFetchUrl(const std::string& extension_id,
const base::Version& version) OVERRIDE {
// TODO(asargent) Factor out common code from the extension updater's
// ManifestFetchData class that can be shared for use here.
std::vector<std::string> parts;
parts.push_back("uc");
parts.push_back("installsource=signature");
parts.push_back("id=" + extension_id);
parts.push_back("v=" + version.GetString());
std::string x_value =
net::EscapeQueryParamValue(JoinString(parts, "&"), true);
std::string query = "response=redirect&x=" + x_value;
GURL base_url = extension_urls::GetWebstoreUpdateUrl();
GURL::Replacements replacements;
replacements.SetQuery(query.c_str(), url::Component(0, query.length()));
return base_url.ReplaceComponents(replacements);
}
virtual std::set<base::FilePath> GetBrowserImagePaths(
const extensions::Extension* extension) OVERRIDE {
return extension_file_util::GetBrowserImagePaths(extension);
}
virtual void VerifyFailed(const std::string& extension_id) OVERRIDE {
if (service_)
service_->DisableExtension(extension_id, Extension::DISABLE_CORRUPTED);
}
static Mode GetDefaultMode() {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
Mode experiment_value = NONE;
const std::string group = base::FieldTrialList::FindFullName(
kContentVerificationExperimentName);
if (group == "EnforceStrict")
experiment_value = ContentVerifierDelegate::ENFORCE_STRICT;
else if (group == "Enforce")
experiment_value = ContentVerifierDelegate::ENFORCE;
else if (group == "Bootstrap")
experiment_value = ContentVerifierDelegate::BOOTSTRAP;
// The field trial value that normally comes from the server can be
// overridden on the command line, which we don't want to allow since
// malware can set chrome command line flags. There isn't currently a way
// to find out what the server-provided value is in this case, so we
// conservatively default to the strictest mode if we detect our experiment
// name being overridden.
if (command_line->HasSwitch(switches::kForceFieldTrials)) {
std::string forced_trials =
command_line->GetSwitchValueASCII(switches::kForceFieldTrials);
if (forced_trials.find(kContentVerificationExperimentName) !=
std::string::npos)
experiment_value = ContentVerifierDelegate::ENFORCE_STRICT;
}
Mode cmdline_value = NONE;
if (command_line->HasSwitch(switches::kExtensionContentVerification)) {
std::string switch_value = command_line->GetSwitchValueASCII(
switches::kExtensionContentVerification);
if (switch_value == switches::kExtensionContentVerificationBootstrap)
cmdline_value = ContentVerifierDelegate::BOOTSTRAP;
else if (switch_value == switches::kExtensionContentVerificationEnforce)
cmdline_value = ContentVerifierDelegate::ENFORCE;
else if (switch_value ==
switches::kExtensionContentVerificationEnforceStrict)
cmdline_value = ContentVerifierDelegate::ENFORCE_STRICT;
else
// If no value was provided (or the wrong one), just default to enforce.
cmdline_value = ContentVerifierDelegate::ENFORCE;
}
// We don't want to allow the command-line flags to eg disable enforcement
// if the experiment group says it should be on, or malware may just modify
// the command line flags. So return the more restrictive of the 2 values.
return std::max(experiment_value, cmdline_value);
}
private:
base::WeakPtr<ExtensionService> service_;
ContentVerifierDelegate::Mode default_mode_;
DISALLOW_COPY_AND_ASSIGN(ContentVerifierDelegateImpl);
};
} // namespace
void ExtensionSystemImpl::Shared::Init(bool extensions_enabled) {
const CommandLine* command_line = CommandLine::ForCurrentProcess();
navigation_observer_.reset(new NavigationObserver(profile_));
bool allow_noisy_errors = !command_line->HasSwitch(switches::kNoErrorDialogs);
ExtensionErrorReporter::Init(allow_noisy_errors);
user_script_master_.reset(new UserScriptMaster(profile_));
// ExtensionService depends on RuntimeData.
runtime_data_.reset(new RuntimeData(ExtensionRegistry::Get(profile_)));
bool autoupdate_enabled = !profile_->IsGuestSession();
#if defined(OS_CHROMEOS)
if (!extensions_enabled)
autoupdate_enabled = false;
#endif
extension_service_.reset(new ExtensionService(
profile_,
CommandLine::ForCurrentProcess(),
profile_->GetPath().AppendASCII(extensions::kInstallDirectoryName),
ExtensionPrefs::Get(profile_),
blacklist_.get(),
autoupdate_enabled,
extensions_enabled,
&ready_));
// These services must be registered before the ExtensionService tries to
// load any extensions.
{
install_verifier_.reset(
new InstallVerifier(ExtensionPrefs::Get(profile_), profile_));
install_verifier_->Init();
content_verifier_ = new ContentVerifier(
profile_, new ContentVerifierDelegateImpl(extension_service_.get()));
ContentVerifierDelegate::Mode mode =
ContentVerifierDelegateImpl::GetDefaultMode();
#if defined(OS_CHROMEOS)
mode = std::max(mode, ContentVerifierDelegate::BOOTSTRAP);
#endif
if (mode > ContentVerifierDelegate::BOOTSTRAP)
content_verifier_->Start();
info_map()->SetContentVerifier(content_verifier_.get());
management_policy_.reset(new ManagementPolicy);
RegisterManagementPolicyProviders();
}
bool skip_session_extensions = false;
#if defined(OS_CHROMEOS)
// Skip loading session extensions if we are not in a user session.
skip_session_extensions = !chromeos::LoginState::Get()->IsUserLoggedIn();
if (chrome::IsRunningInForcedAppMode()) {
extension_service_->component_loader()->
AddDefaultComponentExtensionsForKioskMode(skip_session_extensions);
} else {
extension_service_->component_loader()->AddDefaultComponentExtensions(
skip_session_extensions);
}
#else
extension_service_->component_loader()->AddDefaultComponentExtensions(
skip_session_extensions);
#endif
if (command_line->HasSwitch(switches::kLoadComponentExtension)) {
CommandLine::StringType path_list = command_line->GetSwitchValueNative(
switches::kLoadComponentExtension);
base::StringTokenizerT<CommandLine::StringType,
CommandLine::StringType::const_iterator> t(path_list,
FILE_PATH_LITERAL(","));
while (t.GetNext()) {
// Load the component extension manifest synchronously.
// Blocking the UI thread is acceptable here since
// this flag designated for developers.
base::ThreadRestrictions::ScopedAllowIO allow_io;
extension_service_->component_loader()->AddOrReplace(
base::FilePath(t.token()));
}
}
extension_service_->Init();
#if defined(ENABLE_EXTENSIONS)
// Make the chrome://extension-icon/ resource available.
content::URLDataSource::Add(profile_, new ExtensionIconSource(profile_));
#endif
extension_warning_service_.reset(new ExtensionWarningService(profile_));
extension_warning_badge_service_.reset(
new ExtensionWarningBadgeService(profile_));
extension_warning_service_->AddObserver(
extension_warning_badge_service_.get());
error_console_.reset(new ErrorConsole(profile_));
quota_service_.reset(new QuotaService);
// TODO(thestig): Remove this once ExtensionSystemImpl is no longer built on
// platforms that do not support extensions.
#if defined(ENABLE_EXTENSIONS)
if (extensions_enabled) {
// Load any extensions specified with --load-extension.
// TODO(yoz): Seems like this should move into ExtensionService::Init.
// But maybe it's no longer important.
if (command_line->HasSwitch(switches::kLoadExtension)) {
CommandLine::StringType path_list = command_line->GetSwitchValueNative(
switches::kLoadExtension);
base::StringTokenizerT<CommandLine::StringType,
CommandLine::StringType::const_iterator> t(path_list,
FILE_PATH_LITERAL(","));
while (t.GetNext()) {
std::string extension_id;
UnpackedInstaller::Create(extension_service_.get())->
LoadFromCommandLine(base::FilePath(t.token()), &extension_id);
}
}
}
#endif
}
void ExtensionSystemImpl::Shared::Shutdown() {
if (extension_warning_service_) {
extension_warning_service_->RemoveObserver(
extension_warning_badge_service_.get());
}
if (content_verifier_)
content_verifier_->Shutdown();
if (extension_service_)
extension_service_->Shutdown();
}
StateStore* ExtensionSystemImpl::Shared::state_store() {
return state_store_.get();
}
StateStore* ExtensionSystemImpl::Shared::rules_store() {
return rules_store_.get();
}
ExtensionService* ExtensionSystemImpl::Shared::extension_service() {
return extension_service_.get();
}
RuntimeData* ExtensionSystemImpl::Shared::runtime_data() {
return runtime_data_.get();
}
ManagementPolicy* ExtensionSystemImpl::Shared::management_policy() {
return management_policy_.get();
}
UserScriptMaster* ExtensionSystemImpl::Shared::user_script_master() {
return user_script_master_.get();
}
InfoMap* ExtensionSystemImpl::Shared::info_map() {
if (!extension_info_map_.get())
extension_info_map_ = new InfoMap();
return extension_info_map_.get();
}
LazyBackgroundTaskQueue*
ExtensionSystemImpl::Shared::lazy_background_task_queue() {
return lazy_background_task_queue_.get();
}
EventRouter* ExtensionSystemImpl::Shared::event_router() {
return event_router_.get();
}
ExtensionWarningService* ExtensionSystemImpl::Shared::warning_service() {
return extension_warning_service_.get();
}
Blacklist* ExtensionSystemImpl::Shared::blacklist() {
return blacklist_.get();
}
ErrorConsole* ExtensionSystemImpl::Shared::error_console() {
return error_console_.get();
}
InstallVerifier* ExtensionSystemImpl::Shared::install_verifier() {
return install_verifier_.get();
}
QuotaService* ExtensionSystemImpl::Shared::quota_service() {
return quota_service_.get();
}
ContentVerifier* ExtensionSystemImpl::Shared::content_verifier() {
return content_verifier_.get();
}
//
// ExtensionSystemImpl
//
ExtensionSystemImpl::ExtensionSystemImpl(Profile* profile)
: profile_(profile) {
shared_ = ExtensionSystemSharedFactory::GetForBrowserContext(profile);
if (profile->IsOffTheRecord()) {
process_manager_.reset(ProcessManager::Create(profile));
} else {
shared_->InitPrefs();
}
}
ExtensionSystemImpl::~ExtensionSystemImpl() {
}
void ExtensionSystemImpl::Shutdown() {
process_manager_.reset();
}
void ExtensionSystemImpl::InitForRegularProfile(bool extensions_enabled) {
DCHECK(!profile_->IsOffTheRecord());
if (user_script_master() || extension_service())
return; // Already initialized.
// The InfoMap needs to be created before the ProcessManager.
shared_->info_map();
process_manager_.reset(ProcessManager::Create(profile_));
shared_->Init(extensions_enabled);
}
ExtensionService* ExtensionSystemImpl::extension_service() {
return shared_->extension_service();
}
RuntimeData* ExtensionSystemImpl::runtime_data() {
return shared_->runtime_data();
}
ManagementPolicy* ExtensionSystemImpl::management_policy() {
return shared_->management_policy();
}
UserScriptMaster* ExtensionSystemImpl::user_script_master() {
return shared_->user_script_master();
}
ProcessManager* ExtensionSystemImpl::process_manager() {
return process_manager_.get();
}
StateStore* ExtensionSystemImpl::state_store() {
return shared_->state_store();
}
StateStore* ExtensionSystemImpl::rules_store() {
return shared_->rules_store();
}
InfoMap* ExtensionSystemImpl::info_map() { return shared_->info_map(); }
LazyBackgroundTaskQueue* ExtensionSystemImpl::lazy_background_task_queue() {
return shared_->lazy_background_task_queue();
}
EventRouter* ExtensionSystemImpl::event_router() {
return shared_->event_router();
}
ExtensionWarningService* ExtensionSystemImpl::warning_service() {
return shared_->warning_service();
}
Blacklist* ExtensionSystemImpl::blacklist() {
return shared_->blacklist();
}
const OneShotEvent& ExtensionSystemImpl::ready() const {
return shared_->ready();
}
ErrorConsole* ExtensionSystemImpl::error_console() {
return shared_->error_console();
}
InstallVerifier* ExtensionSystemImpl::install_verifier() {
return shared_->install_verifier();
}
QuotaService* ExtensionSystemImpl::quota_service() {
return shared_->quota_service();
}
ContentVerifier* ExtensionSystemImpl::content_verifier() {
return shared_->content_verifier();
}
scoped_ptr<ExtensionSet> ExtensionSystemImpl::GetDependentExtensions(
const Extension* extension) {
return extension_service()->shared_module_service()->GetDependentExtensions(
extension);
}
void ExtensionSystemImpl::RegisterExtensionWithRequestContexts(
const Extension* extension) {
base::Time install_time;
if (extension->location() != Manifest::COMPONENT) {
install_time = ExtensionPrefs::Get(profile_)->
GetInstallTime(extension->id());
}
bool incognito_enabled = util::IsIncognitoEnabled(extension->id(), profile_);
bool notifications_disabled = false;
#if defined(ENABLE_NOTIFICATIONS)
message_center::NotifierId notifier_id(
message_center::NotifierId::APPLICATION,
extension->id());
DesktopNotificationService* notification_service =
DesktopNotificationServiceFactory::GetForProfile(profile_);
notifications_disabled =
!notification_service->IsNotifierEnabled(notifier_id);
#endif
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&InfoMap::AddExtension, info_map(),
make_scoped_refptr(extension), install_time,
incognito_enabled, notifications_disabled));
}
void ExtensionSystemImpl::UnregisterExtensionWithRequestContexts(
const std::string& extension_id,
const UnloadedExtensionInfo::Reason reason) {
BrowserThread::PostTask(
BrowserThread::IO,
FROM_HERE,
base::Bind(&InfoMap::RemoveExtension, info_map(), extension_id, reason));
}
} // namespace extensions