| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/ash/extensions/test_external_cache.h" |
| |
| #include <utility> |
| |
| #include "base/functional/callback.h" |
| #include "base/values.h" |
| #include "chrome/browser/ash/extensions/external_cache_delegate.h" |
| #include "chrome/browser/extensions/external_provider_impl.h" |
| #include "extensions/browser/updater/extension_downloader_delegate.h" |
| |
| namespace chromeos { |
| |
| TestExternalCache::TestExternalCache(ExternalCacheDelegate* delegate, |
| bool always_check_for_updates) |
| : delegate_(delegate), |
| always_check_for_updates_(always_check_for_updates) {} |
| |
| TestExternalCache::~TestExternalCache() = default; |
| |
| const base::Value::Dict& TestExternalCache::GetCachedExtensions() { |
| return cached_extensions_; |
| } |
| |
| void TestExternalCache::Shutdown(base::OnceClosure callback) { |
| std::move(callback).Run(); |
| } |
| |
| void TestExternalCache::UpdateExtensionsList(base::Value::Dict prefs) { |
| configured_extensions_ = std::move(prefs); |
| cached_extensions_.clear(); |
| |
| if (configured_extensions_.empty()) { |
| delegate_->OnExtensionListsUpdated(cached_extensions_); |
| return; |
| } |
| |
| UpdateCachedExtensions(); |
| } |
| |
| void TestExternalCache::OnDamagedFileDetected(const base::FilePath& path) { |
| for (const auto [id, value] : cached_extensions_) { |
| const std::string* entry_path = |
| value.is_dict() ? value.GetDict().FindString( |
| extensions::ExternalProviderImpl::kExternalCrx) |
| : nullptr; |
| if (entry_path && *entry_path == path.value()) { |
| RemoveExtensions({id}); |
| return; |
| } |
| } |
| } |
| |
| void TestExternalCache::RemoveExtensions(const std::vector<std::string>& ids) { |
| if (ids.empty()) |
| return; |
| |
| for (const auto& id : ids) { |
| cached_extensions_.Remove(id); |
| configured_extensions_.Remove(id); |
| crx_cache_.erase(id); |
| } |
| |
| delegate_->OnExtensionListsUpdated(cached_extensions_); |
| } |
| |
| bool TestExternalCache::GetExtension(const std::string& id, |
| base::FilePath* file_path, |
| std::string* version) { |
| if (!crx_cache_.count(id)) |
| return false; |
| *file_path = base::FilePath(crx_cache_[id].path); |
| *version = crx_cache_[id].version; |
| return true; |
| } |
| |
| bool TestExternalCache::ExtensionFetchPending(const std::string& id) { |
| return configured_extensions_.Find(id) && !cached_extensions_.Find(id); |
| } |
| |
| void TestExternalCache::PutExternalExtension( |
| const std::string& id, |
| const base::FilePath& crx_file_path, |
| const std::string& version, |
| PutExternalExtensionCallback callback) { |
| AddEntryToCrxCache(id, crx_file_path.value(), version); |
| std::move(callback).Run(id, true); |
| } |
| |
| void TestExternalCache::SetBackoffPolicy( |
| std::optional<net::BackoffEntry::Policy> new_backoff_policy) { |
| backoff_policy_ = new_backoff_policy; |
| } |
| |
| bool TestExternalCache::SimulateExtensionDownloadFinished( |
| const std::string& id, |
| const std::string& crx_path, |
| const std::string& version, |
| bool is_update) { |
| if (!pending_downloads_.count(id)) |
| return false; |
| |
| AddEntryToCrxCache(id, crx_path, version); |
| delegate_->OnExtensionLoadedInCache(id, is_update); |
| return true; |
| } |
| |
| bool TestExternalCache::SimulateExtensionDownloadFailed( |
| const std::string& id, |
| extensions::ExtensionDownloaderDelegate::Error error) { |
| if (!pending_downloads_.count(id)) |
| return false; |
| |
| delegate_->OnExtensionDownloadFailed(id, error); |
| return true; |
| } |
| |
| void TestExternalCache::UpdateCachedExtensions() { |
| for (const auto [id, value] : configured_extensions_) { |
| DCHECK(value.is_dict()); |
| if (GetExtensionUpdateUrl(value.GetDict(), always_check_for_updates_) |
| .is_valid()) { |
| pending_downloads_.insert(id); |
| } |
| |
| if (crx_cache_.count(id)) { |
| cached_extensions_.Set( |
| id, GetExtensionValueToCache(value.GetDict(), crx_cache_[id].path, |
| crx_cache_[id].version)); |
| } else if (ShouldCacheImmediately(value.GetDict())) { |
| cached_extensions_.Set(id, value.Clone()); |
| } |
| } |
| |
| delegate_->OnExtensionListsUpdated(cached_extensions_); |
| } |
| |
| void TestExternalCache::AddEntryToCrxCache(const std::string& id, |
| const std::string& crx_path, |
| const std::string& version) { |
| crx_cache_[id] = {crx_path, version}; |
| |
| if (const base::Value::Dict* extension = |
| configured_extensions_.FindDict(id)) { |
| cached_extensions_.Set( |
| id, GetExtensionValueToCache(*extension, crx_path, version)); |
| delegate_->OnExtensionListsUpdated(cached_extensions_); |
| } |
| } |
| |
| } // namespace chromeos |