| // Copyright (c) 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/chromeos/extensions/external_cache.h" |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/callback.h" |
| #include "base/file_util.h" |
| #include "base/files/file_enumerator.h" |
| #include "base/location.h" |
| #include "base/logging.h" |
| #include "base/strings/string_util.h" |
| #include "base/values.h" |
| #include "base/version.h" |
| #include "chrome/browser/chrome_notification_types.h" |
| #include "chrome/browser/extensions/crx_installer.h" |
| #include "chrome/browser/extensions/external_provider_impl.h" |
| #include "chrome/browser/extensions/updater/extension_downloader.h" |
| #include "chrome/common/extensions/extension_constants.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/notification_details.h" |
| #include "content/public/browser/notification_service.h" |
| #include "content/public/browser/notification_source.h" |
| #include "extensions/common/extension.h" |
| |
| namespace chromeos { |
| |
| namespace { |
| |
| // File name extension for CRX files (not case sensitive). |
| const char kCRXFileExtension[] = ".crx"; |
| |
| // Delay between checks for flag file presence when waiting for the cache to |
| // become ready. |
| const int64_t kCacheStatusPollingDelayMs = 1000; |
| |
| } // namespace |
| |
| const char ExternalCache::kCacheReadyFlagFileName[] = ".initialized"; |
| |
| ExternalCache::ExternalCache(const base::FilePath& cache_dir, |
| net::URLRequestContextGetter* request_context, |
| const scoped_refptr<base::SequencedTaskRunner>& |
| backend_task_runner, |
| Delegate* delegate, |
| bool always_check_updates, |
| bool wait_for_cache_initialization) |
| : cache_dir_(cache_dir), |
| request_context_(request_context), |
| delegate_(delegate), |
| shutdown_(false), |
| always_check_updates_(always_check_updates), |
| wait_for_cache_initialization_(wait_for_cache_initialization), |
| cached_extensions_(new base::DictionaryValue()), |
| backend_task_runner_(backend_task_runner), |
| weak_ptr_factory_(this) { |
| notification_registrar_.Add( |
| this, |
| chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR, |
| content::NotificationService::AllBrowserContextsAndSources()); |
| } |
| |
| ExternalCache::~ExternalCache() { |
| } |
| |
| void ExternalCache::Shutdown(const base::Closure& callback) { |
| DCHECK(!shutdown_); |
| shutdown_ = true; |
| backend_task_runner_->PostTask(FROM_HERE, |
| base::Bind(&ExternalCache::BackendShudown, |
| callback)); |
| } |
| |
| void ExternalCache::UpdateExtensionsList( |
| scoped_ptr<base::DictionaryValue> prefs) { |
| if (shutdown_) |
| return; |
| |
| extensions_ = prefs.Pass(); |
| if (extensions_->empty()) { |
| // Don't check cache and clear it if there are no extensions in the list. |
| // It is important case because login to supervised user shouldn't clear |
| // cache for normal users. |
| // TODO(dpolukhin): introduce reference counting to preserve cache elements |
| // when they are not needed for current user but needed for other users. |
| cached_extensions_->Clear(); |
| UpdateExtensionLoader(); |
| } else { |
| CheckCache(); |
| } |
| } |
| |
| void ExternalCache::OnDamagedFileDetected(const base::FilePath& path) { |
| if (shutdown_) |
| return; |
| |
| for (base::DictionaryValue::Iterator it(*cached_extensions_.get()); |
| !it.IsAtEnd(); it.Advance()) { |
| const base::DictionaryValue* entry = NULL; |
| if (!it.value().GetAsDictionary(&entry)) { |
| NOTREACHED() << "ExternalCache found bad entry with type " |
| << it.value().GetType(); |
| continue; |
| } |
| |
| std::string external_crx; |
| if (entry->GetString(extensions::ExternalProviderImpl::kExternalCrx, |
| &external_crx) && |
| external_crx == path.value()) { |
| |
| LOG(ERROR) << "ExternalCache extension at " << path.value() |
| << " failed to install, deleting it."; |
| cached_extensions_->Remove(it.key(), NULL); |
| UpdateExtensionLoader(); |
| |
| // The file will be downloaded again on the next restart. |
| if (cache_dir_.IsParent(path)) { |
| backend_task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind(base::IgnoreResult(base::DeleteFile), |
| path, |
| true)); |
| } |
| |
| // Don't try to DownloadMissingExtensions() from here, |
| // since it can cause a fail/retry loop. |
| return; |
| } |
| } |
| LOG(ERROR) << "ExternalCache cannot find external_crx " << path.value(); |
| } |
| |
| void ExternalCache::Observe(int type, |
| const content::NotificationSource& source, |
| const content::NotificationDetails& details) { |
| if (shutdown_) |
| return; |
| |
| switch (type) { |
| case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR: { |
| extensions::CrxInstaller* installer = |
| content::Source<extensions::CrxInstaller>(source).ptr(); |
| OnDamagedFileDetected(installer->source_file()); |
| break; |
| } |
| |
| default: |
| NOTREACHED(); |
| } |
| } |
| |
| void ExternalCache::OnExtensionDownloadFailed( |
| const std::string& id, |
| extensions::ExtensionDownloaderDelegate::Error error, |
| const extensions::ExtensionDownloaderDelegate::PingResult& ping_result, |
| const std::set<int>& request_ids) { |
| if (shutdown_) |
| return; |
| |
| if (error == NO_UPDATE_AVAILABLE) { |
| if (!cached_extensions_->HasKey(id)) { |
| LOG(ERROR) << "ExternalCache extension " << id |
| << " not found on update server"; |
| } |
| } else { |
| LOG(ERROR) << "ExternalCache failed to download extension " << id |
| << ", error " << error; |
| } |
| } |
| |
| void ExternalCache::OnExtensionDownloadFinished( |
| const std::string& id, |
| const base::FilePath& path, |
| const GURL& download_url, |
| const std::string& version, |
| const extensions::ExtensionDownloaderDelegate::PingResult& ping_result, |
| const std::set<int>& request_ids) { |
| if (shutdown_) |
| return; |
| |
| backend_task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind(&ExternalCache::BackendInstallCacheEntry, |
| weak_ptr_factory_.GetWeakPtr(), |
| cache_dir_, |
| id, |
| path, |
| version)); |
| } |
| |
| bool ExternalCache::IsExtensionPending(const std::string& id) { |
| // Pending means that there is no installed version yet. |
| return extensions_->HasKey(id) && !cached_extensions_->HasKey(id); |
| } |
| |
| bool ExternalCache::GetExtensionExistingVersion(const std::string& id, |
| std::string* version) { |
| DictionaryValue* extension_dictionary = NULL; |
| if (cached_extensions_->GetDictionary(id, &extension_dictionary)) { |
| if (extension_dictionary->GetString( |
| extensions::ExternalProviderImpl::kExternalVersion, version)) { |
| return true; |
| } |
| *version = delegate_->GetInstalledExtensionVersion(id); |
| return !version->empty(); |
| } |
| return false; |
| } |
| |
| void ExternalCache::UpdateExtensionLoader() { |
| if (shutdown_) |
| return; |
| |
| VLOG(1) << "Notify ExternalCache delegate about cache update"; |
| if (delegate_) |
| delegate_->OnExtensionListsUpdated(cached_extensions_.get()); |
| } |
| |
| void ExternalCache::CheckCache() { |
| if (wait_for_cache_initialization_) { |
| backend_task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind(&ExternalCache::BackendCheckCacheStatus, |
| weak_ptr_factory_.GetWeakPtr(), |
| cache_dir_)); |
| } else { |
| CheckCacheContents(); |
| } |
| } |
| |
| // static |
| void ExternalCache::BackendCheckCacheStatus( |
| base::WeakPtr<ExternalCache> external_cache, |
| const base::FilePath& cache_dir) { |
| content::BrowserThread::PostTask( |
| content::BrowserThread::UI, |
| FROM_HERE, |
| base::Bind(&ExternalCache::OnCacheStatusChecked, |
| external_cache, |
| base::PathExists(cache_dir.AppendASCII(kCacheReadyFlagFileName)))); |
| } |
| |
| void ExternalCache::OnCacheStatusChecked(bool ready) { |
| if (shutdown_) |
| return; |
| |
| if (ready) { |
| CheckCacheContents(); |
| } else { |
| content::BrowserThread::PostDelayedTask( |
| content::BrowserThread::UI, |
| FROM_HERE, |
| base::Bind(&ExternalCache::CheckCache, |
| weak_ptr_factory_.GetWeakPtr()), |
| base::TimeDelta::FromMilliseconds(kCacheStatusPollingDelayMs)); |
| } |
| } |
| |
| void ExternalCache::CheckCacheContents() { |
| if (shutdown_) |
| return; |
| |
| backend_task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind(&ExternalCache::BackendCheckCacheContents, |
| weak_ptr_factory_.GetWeakPtr(), |
| cache_dir_, |
| base::Passed(make_scoped_ptr(extensions_->DeepCopy())))); |
| } |
| |
| // static |
| void ExternalCache::BackendCheckCacheContents( |
| base::WeakPtr<ExternalCache> external_cache, |
| const base::FilePath& cache_dir, |
| scoped_ptr<base::DictionaryValue> prefs) { |
| BackendCheckCacheContentsInternal(cache_dir, prefs.get()); |
| content::BrowserThread::PostTask(content::BrowserThread::UI, |
| FROM_HERE, |
| base::Bind(&ExternalCache::OnCacheUpdated, |
| external_cache, |
| base::Passed(&prefs))); |
| } |
| |
| // static |
| void ExternalCache::BackendCheckCacheContentsInternal( |
| const base::FilePath& cache_dir, |
| base::DictionaryValue* prefs) { |
| // Start by verifying that the cache_dir exists. |
| if (!base::DirectoryExists(cache_dir)) { |
| // Create it now. |
| if (!base::CreateDirectory(cache_dir)) { |
| LOG(ERROR) << "Failed to create ExternalCache directory at " |
| << cache_dir.value(); |
| } |
| |
| // Nothing else to do. Cache won't be used. |
| return; |
| } |
| |
| // Enumerate all the files in the cache |cache_dir|, including directories |
| // and symlinks. Each unrecognized file will be erased. |
| int types = base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES | |
| base::FileEnumerator::SHOW_SYM_LINKS; |
| base::FileEnumerator enumerator(cache_dir, false /* recursive */, types); |
| for (base::FilePath path = enumerator.Next(); |
| !path.empty(); path = enumerator.Next()) { |
| base::FileEnumerator::FileInfo info = enumerator.GetInfo(); |
| std::string basename = path.BaseName().value(); |
| |
| if (info.IsDirectory() || base::IsLink(info.GetName())) { |
| LOG(ERROR) << "Erasing bad file in ExternalCache directory: " << basename; |
| base::DeleteFile(path, true /* recursive */); |
| continue; |
| } |
| |
| // Skip flag file that indicates that cache is ready. |
| if (basename == kCacheReadyFlagFileName) |
| continue; |
| |
| // crx files in the cache are named <extension-id>-<version>.crx. |
| std::string id; |
| std::string version; |
| if (EndsWith(basename, kCRXFileExtension, false /* case-sensitive */)) { |
| size_t n = basename.find('-'); |
| if (n != std::string::npos && n + 1 < basename.size() - 4) { |
| id = basename.substr(0, n); |
| // Size of |version| = total size - "<id>" - "-" - ".crx" |
| version = basename.substr(n + 1, basename.size() - 5 - id.size()); |
| } |
| } |
| |
| base::DictionaryValue* entry = NULL; |
| if (!extensions::Extension::IdIsValid(id)) { |
| LOG(ERROR) << "Bad extension id in ExternalCache: " << id; |
| id.clear(); |
| } else if (!prefs->GetDictionary(id, &entry)) { |
| LOG(WARNING) << basename << " is in the cache but is not configured by " |
| << "the ExternalCache source, and will be erased."; |
| id.clear(); |
| } |
| |
| if (!Version(version).IsValid()) { |
| LOG(ERROR) << "Bad extension version in ExternalCache: " << version; |
| version.clear(); |
| } |
| |
| if (id.empty() || version.empty()) { |
| LOG(ERROR) << "Invalid file in ExternalCache, erasing: " << basename; |
| base::DeleteFile(path, true /* recursive */); |
| continue; |
| } |
| |
| // Enforce a lower-case id. |
| id = StringToLowerASCII(id); |
| |
| std::string update_url; |
| std::string prev_version_string; |
| std::string prev_crx; |
| if (entry->GetString(extensions::ExternalProviderImpl::kExternalUpdateUrl, |
| &update_url)) { |
| VLOG(1) << "ExternalCache found cached version " << version |
| << " for extension id: " << id; |
| entry->Remove(extensions::ExternalProviderImpl::kExternalUpdateUrl, NULL); |
| entry->SetString(extensions::ExternalProviderImpl::kExternalVersion, |
| version); |
| entry->SetString(extensions::ExternalProviderImpl::kExternalCrx, |
| path.value()); |
| if (extension_urls::IsWebstoreUpdateUrl(GURL(update_url))) { |
| entry->SetBoolean(extensions::ExternalProviderImpl::kIsFromWebstore, |
| true); |
| } |
| } else if ( |
| entry->GetString(extensions::ExternalProviderImpl::kExternalVersion, |
| &prev_version_string) && |
| entry->GetString(extensions::ExternalProviderImpl::kExternalCrx, |
| &prev_crx)) { |
| Version prev_version(prev_version_string); |
| Version curr_version(version); |
| DCHECK(prev_version.IsValid()); |
| DCHECK(curr_version.IsValid()); |
| if (prev_version.CompareTo(curr_version) <= 0) { |
| VLOG(1) << "ExternalCache found old cached version " |
| << prev_version_string << " path: " << prev_crx; |
| base::FilePath prev_crx_file(prev_crx); |
| if (cache_dir.IsParent(prev_crx_file)) { |
| // Only delete old cached files under cache_dir_ folder. |
| base::DeleteFile(base::FilePath(prev_crx), true /* recursive */); |
| } |
| entry->SetString(extensions::ExternalProviderImpl::kExternalVersion, |
| version); |
| entry->SetString(extensions::ExternalProviderImpl::kExternalCrx, |
| path.value()); |
| } else { |
| VLOG(1) << "ExternalCache found old cached version " |
| << version << " path: " << path.value(); |
| base::DeleteFile(path, true /* recursive */); |
| } |
| } else { |
| NOTREACHED() << "ExternalCache found bad entry for extension id: " << id |
| << " file path: " << path.value(); |
| } |
| } |
| } |
| |
| void ExternalCache::OnCacheUpdated(scoped_ptr<base::DictionaryValue> prefs) { |
| DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| if (shutdown_) |
| return; |
| |
| // If request_context_ is missing we can't download anything. |
| if (!downloader_ && request_context_) { |
| downloader_.reset( |
| new extensions::ExtensionDownloader(this, request_context_)); |
| } |
| |
| cached_extensions_->Clear(); |
| for (base::DictionaryValue::Iterator it(*extensions_.get()); |
| !it.IsAtEnd(); it.Advance()) { |
| const base::DictionaryValue* entry = NULL; |
| if (!it.value().GetAsDictionary(&entry)) { |
| LOG(ERROR) << "ExternalCache found bad entry with type " |
| << it.value().GetType(); |
| continue; |
| } |
| |
| bool keep_if_present = |
| entry->HasKey(extensions::ExternalProviderImpl::kKeepIfPresent); |
| // Check for updates for all extensions configured except for extensions |
| // marked as keep_if_present. |
| if (downloader_ && !keep_if_present) { |
| GURL update_url; |
| std::string external_update_url; |
| if (entry->GetString(extensions::ExternalProviderImpl::kExternalUpdateUrl, |
| &external_update_url)) { |
| update_url = GURL(external_update_url); |
| } else if (always_check_updates_) { |
| update_url = extension_urls::GetWebstoreUpdateUrl(); |
| } |
| if (update_url.is_valid()) |
| downloader_->AddPendingExtension(it.key(), update_url, 0); |
| } |
| |
| base::DictionaryValue* cached_entry = NULL; |
| if (prefs->GetDictionary(it.key(), &cached_entry)) { |
| bool has_external_crx = cached_entry->HasKey( |
| extensions::ExternalProviderImpl::kExternalCrx); |
| bool is_already_installed = |
| !delegate_->GetInstalledExtensionVersion(it.key()).empty(); |
| if (!downloader_ || keep_if_present || has_external_crx || |
| is_already_installed) { |
| scoped_ptr<base::Value> value; |
| prefs->Remove(it.key(), &value); |
| cached_extensions_->Set(it.key(), value.release()); |
| } |
| } |
| } |
| if (downloader_) |
| downloader_->StartAllPending(); |
| |
| VLOG(1) << "Updated ExternalCache, there are " |
| << cached_extensions_->size() << " extensions cached"; |
| |
| UpdateExtensionLoader(); |
| } |
| |
| // static |
| void ExternalCache::BackendInstallCacheEntry( |
| base::WeakPtr<ExternalCache> external_cache, |
| const base::FilePath& cache_dir, |
| const std::string& id, |
| const base::FilePath& path, |
| const std::string& version) { |
| Version version_validator(version); |
| if (!version_validator.IsValid()) { |
| LOG(ERROR) << "ExternalCache downloaded extension " << id << " but got bad " |
| << "version: " << version; |
| base::DeleteFile(path, true /* recursive */); |
| return; |
| } |
| |
| std::string basename = id + "-" + version + kCRXFileExtension; |
| base::FilePath cached_crx_path = cache_dir.Append(basename); |
| |
| if (base::PathExists(cached_crx_path)) { |
| LOG(WARNING) << "AppPack downloaded a crx whose filename will overwrite " |
| << "an existing cached crx."; |
| base::DeleteFile(cached_crx_path, true /* recursive */); |
| } |
| |
| if (!base::DirectoryExists(cache_dir)) { |
| LOG(ERROR) << "AppPack cache directory does not exist, creating now: " |
| << cache_dir.value(); |
| if (!base::CreateDirectory(cache_dir)) { |
| LOG(ERROR) << "Failed to create the AppPack cache dir!"; |
| base::DeleteFile(path, true /* recursive */); |
| return; |
| } |
| } |
| |
| if (!base::Move(path, cached_crx_path)) { |
| LOG(ERROR) << "Failed to move AppPack crx from " << path.value() |
| << " to " << cached_crx_path.value(); |
| base::DeleteFile(path, true /* recursive */); |
| return; |
| } |
| |
| content::BrowserThread::PostTask( |
| content::BrowserThread::UI, |
| FROM_HERE, |
| base::Bind(&ExternalCache::OnCacheEntryInstalled, |
| external_cache, |
| id, |
| cached_crx_path, |
| version)); |
| } |
| |
| void ExternalCache::OnCacheEntryInstalled(const std::string& id, |
| const base::FilePath& path, |
| const std::string& version) { |
| if (shutdown_) |
| return; |
| |
| VLOG(1) << "AppPack installed a new extension in the cache: " << path.value(); |
| |
| base::DictionaryValue* entry = NULL; |
| if (!extensions_->GetDictionary(id, &entry)) { |
| LOG(ERROR) << "ExternalCache cannot find entry for extension " << id; |
| return; |
| } |
| |
| // Copy entry to don't modify it inside extensions_. |
| entry = entry->DeepCopy(); |
| |
| std::string update_url; |
| if (entry->GetString(extensions::ExternalProviderImpl::kExternalUpdateUrl, |
| &update_url) && |
| extension_urls::IsWebstoreUpdateUrl(GURL(update_url))) { |
| entry->SetBoolean(extensions::ExternalProviderImpl::kIsFromWebstore, true); |
| } |
| entry->Remove(extensions::ExternalProviderImpl::kExternalUpdateUrl, NULL); |
| entry->SetString(extensions::ExternalProviderImpl::kExternalVersion, version); |
| entry->SetString(extensions::ExternalProviderImpl::kExternalCrx, |
| path.value()); |
| |
| cached_extensions_->Set(id, entry); |
| UpdateExtensionLoader(); |
| } |
| |
| // static |
| void ExternalCache::BackendShudown(const base::Closure& callback) { |
| content::BrowserThread::PostTask(content::BrowserThread::UI, |
| FROM_HERE, |
| callback); |
| } |
| |
| std::string ExternalCache::Delegate::GetInstalledExtensionVersion( |
| const std::string& id) { |
| return std::string(); |
| } |
| |
| } // namespace chromeos |
