blob: 4c8a33f1d4c12c37a7dd1f64d08d97f38b6b3ddc [file] [log] [blame]
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "apps/saved_files_service.h"
#include <stdint.h>
#include <algorithm>
#include <map>
#include <memory>
#include <optional>
#include <unordered_map>
#include <utility>
#include "apps/saved_files_service_factory.h"
#include "base/json/values_util.h"
#include "base/memory/raw_ptr.h"
#include "base/not_fatal_until.h"
#include "build/chromeos_buildflags.h"
#include "content/public/browser/browser_context.h"
#include "extensions/browser/api/file_system/saved_file_entry.h"
#include "extensions/browser/extension_host.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_system.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/permissions/api_permission.h"
#include "extensions/common/permissions/permission_set.h"
#include "extensions/common/permissions/permissions_data.h"
namespace apps {
using extensions::APIPermission;
using extensions::Extension;
using extensions::ExtensionHost;
using extensions::ExtensionPrefs;
using extensions::SavedFileEntry;
namespace {
// Preference keys
// The file entries that the app has permission to access.
const char kFileEntries[] = "file_entries";
// The path to a file entry that the app had permission to access.
const char kFileEntryPath[] = "path";
// Whether or not the the entry refers to a directory.
const char kFileEntryIsDirectory[] = "is_directory";
// The sequence number in the LRU of the file entry.
const char kFileEntrySequenceNumber[] = "sequence_number";
const size_t kMaxSavedFileEntries = 500;
const int kMaxSequenceNumber = INT32_MAX;
// These might be different to the constant values in tests.
size_t g_max_saved_file_entries = kMaxSavedFileEntries;
int g_max_sequence_number = kMaxSequenceNumber;
// Persists a SavedFileEntry in ExtensionPrefs.
void AddSavedFileEntry(ExtensionPrefs* prefs,
const extensions::ExtensionId& extension_id,
const SavedFileEntry& file_entry) {
ExtensionPrefs::ScopedDictionaryUpdate update(
prefs, extension_id, kFileEntries);
auto file_entries = update.Create();
DCHECK(
!file_entries->GetDictionaryWithoutPathExpansion(file_entry.id, nullptr));
base::Value::Dict file_entry_dict;
file_entry_dict.Set(kFileEntryPath, base::FilePathToValue(file_entry.path));
file_entry_dict.Set(kFileEntryIsDirectory, file_entry.is_directory);
file_entry_dict.Set(kFileEntrySequenceNumber, file_entry.sequence_number);
file_entries->SetDictionaryWithoutPathExpansion(file_entry.id,
std::move(file_entry_dict));
}
// Updates the sequence_number of a SavedFileEntry persisted in ExtensionPrefs.
void UpdateSavedFileEntry(ExtensionPrefs* prefs,
const extensions::ExtensionId& extension_id,
const SavedFileEntry& file_entry) {
ExtensionPrefs::ScopedDictionaryUpdate update(
prefs, extension_id, kFileEntries);
auto file_entries = update.Get();
DCHECK(file_entries);
std::unique_ptr<prefs::DictionaryValueUpdate> file_entry_dict;
file_entries->GetDictionaryWithoutPathExpansion(file_entry.id,
&file_entry_dict);
DCHECK(file_entry_dict);
file_entry_dict->SetInteger(kFileEntrySequenceNumber,
file_entry.sequence_number);
}
// Removes a SavedFileEntry from ExtensionPrefs.
void RemoveSavedFileEntry(ExtensionPrefs* prefs,
const extensions::ExtensionId& extension_id,
const std::string& file_entry_id) {
ExtensionPrefs::ScopedDictionaryUpdate update(
prefs, extension_id, kFileEntries);
auto file_entries = update.Create();
file_entries->RemoveWithoutPathExpansion(file_entry_id, NULL);
}
// Clears all SavedFileEntry for the app from ExtensionPrefs.
void ClearSavedFileEntries(ExtensionPrefs* prefs,
const extensions::ExtensionId& extension_id) {
prefs->UpdateExtensionPref(extension_id, kFileEntries, std::nullopt);
}
// Returns all SavedFileEntries for the app.
std::vector<SavedFileEntry> GetSavedFileEntries(
ExtensionPrefs* prefs,
const extensions::ExtensionId& extension_id) {
std::vector<SavedFileEntry> result;
const auto* dict = prefs->ReadPrefAsDict(extension_id, kFileEntries);
if (!dict) {
return result;
}
for (const auto item : *dict) {
const auto* file_entry = item.second.GetIfDict();
if (!file_entry)
continue;
const base::Value* path_value = file_entry->Find(kFileEntryPath);
if (!path_value)
continue;
std::optional<base::FilePath> file_path =
base::ValueToFilePath(*path_value);
if (!file_path)
continue;
bool is_directory =
file_entry->FindBool(kFileEntryIsDirectory).value_or(false);
const std::optional<int> sequence_number =
file_entry->FindInt(kFileEntrySequenceNumber);
if (!sequence_number || sequence_number.value() == 0)
continue;
result.emplace_back(item.first, *file_path, is_directory,
sequence_number.value());
}
return result;
}
} // namespace
class SavedFilesService::SavedFiles {
public:
SavedFiles(content::BrowserContext* context,
const extensions::ExtensionId& extension_id);
SavedFiles(const SavedFiles&) = delete;
SavedFiles& operator=(const SavedFiles&) = delete;
~SavedFiles();
void RegisterFileEntry(const std::string& id,
const base::FilePath& file_path,
bool is_directory);
void EnqueueFileEntry(const std::string& id);
bool IsRegistered(const std::string& id) const;
const SavedFileEntry* GetFileEntry(const std::string& id) const;
std::vector<SavedFileEntry> GetAllFileEntries() const;
private:
// Compacts sequence numbers if the largest sequence number is
// g_max_sequence_number. Outside of testing, it is set to kint32max, so this
// will almost never do any real work.
void MaybeCompactSequenceNumbers();
void LoadSavedFileEntriesFromPreferences();
raw_ptr<content::BrowserContext> context_;
const extensions::ExtensionId extension_id_;
// Contains all file entries that have been registered, keyed by ID.
std::unordered_map<std::string, std::unique_ptr<SavedFileEntry>>
registered_file_entries_;
// The queue of file entries that have been retained, keyed by
// sequence_number. Values are a subset of values in registered_file_entries_.
// This should be kept in sync with file entries stored in extension prefs.
std::map<int, SavedFileEntry*> saved_file_lru_;
};
// static
SavedFilesService* SavedFilesService::Get(content::BrowserContext* context) {
return SavedFilesServiceFactory::GetForBrowserContext(context);
}
SavedFilesService::SavedFilesService(content::BrowserContext* context)
: context_(context) {
extension_host_registry_observation_.Observe(
extensions::ExtensionHostRegistry::Get(context_));
}
SavedFilesService::~SavedFilesService() = default;
void SavedFilesService::OnExtensionHostDestroyed(
content::BrowserContext* browser_context,
extensions::ExtensionHost* host) {
const Extension* extension = host->extension();
if (extension) {
ClearQueueIfNoRetainPermission(extension);
Clear(extension->id());
}
}
void SavedFilesService::RegisterFileEntry(
const extensions::ExtensionId& extension_id,
const std::string& id,
const base::FilePath& file_path,
bool is_directory) {
GetOrInsert(extension_id)->RegisterFileEntry(id, file_path, is_directory);
}
void SavedFilesService::EnqueueFileEntry(
const extensions::ExtensionId& extension_id,
const std::string& id) {
GetOrInsert(extension_id)->EnqueueFileEntry(id);
}
std::vector<SavedFileEntry> SavedFilesService::GetAllFileEntries(
const extensions::ExtensionId& extension_id) {
SavedFiles* saved_files = Get(extension_id);
if (saved_files)
return saved_files->GetAllFileEntries();
return GetSavedFileEntries(ExtensionPrefs::Get(context_), extension_id);
}
bool SavedFilesService::IsRegistered(
const extensions::ExtensionId& extension_id,
const std::string& id) {
return GetOrInsert(extension_id)->IsRegistered(id);
}
const SavedFileEntry* SavedFilesService::GetFileEntry(
const extensions::ExtensionId& extension_id,
const std::string& id) {
return GetOrInsert(extension_id)->GetFileEntry(id);
}
void SavedFilesService::ClearQueueIfNoRetainPermission(
const Extension* extension) {
if (!extension->permissions_data()->active_permissions().HasAPIPermission(
extensions::mojom::APIPermissionID::kFileSystemRetainEntries)) {
ClearQueue(extension);
}
}
void SavedFilesService::ClearQueue(const extensions::Extension* extension) {
ClearSavedFileEntries(ExtensionPrefs::Get(context_), extension->id());
Clear(extension->id());
}
void SavedFilesService::OnApplicationTerminating() {
// Stop listening to ExtensionHost shutdown as all extension hosts will be
// destroyed as a result of shutdown.
extension_host_registry_observation_.Reset();
}
SavedFilesService::SavedFiles* SavedFilesService::Get(
const extensions::ExtensionId& extension_id) const {
auto it = extension_id_to_saved_files_.find(extension_id);
if (it != extension_id_to_saved_files_.end())
return it->second.get();
return NULL;
}
SavedFilesService::SavedFiles* SavedFilesService::GetOrInsert(
const extensions::ExtensionId& extension_id) {
SavedFiles* saved_files = Get(extension_id);
if (saved_files)
return saved_files;
std::unique_ptr<SavedFiles> scoped_saved_files(
new SavedFiles(context_, extension_id));
saved_files = scoped_saved_files.get();
extension_id_to_saved_files_.insert(
std::make_pair(extension_id, std::move(scoped_saved_files)));
return saved_files;
}
void SavedFilesService::Clear(const extensions::ExtensionId& extension_id) {
extension_id_to_saved_files_.erase(extension_id);
}
SavedFilesService::SavedFiles::SavedFiles(
content::BrowserContext* context,
const extensions::ExtensionId& extension_id)
: context_(context), extension_id_(extension_id) {
LoadSavedFileEntriesFromPreferences();
}
SavedFilesService::SavedFiles::~SavedFiles() = default;
void SavedFilesService::SavedFiles::RegisterFileEntry(
const std::string& id,
const base::FilePath& file_path,
bool is_directory) {
auto it = registered_file_entries_.find(id);
if (it != registered_file_entries_.end())
return;
registered_file_entries_[id] =
std::make_unique<SavedFileEntry>(id, file_path, is_directory, 0);
}
void SavedFilesService::SavedFiles::EnqueueFileEntry(const std::string& id) {
auto id_it = registered_file_entries_.find(id);
CHECK(id_it != registered_file_entries_.end(), base::NotFatalUntil::M130);
SavedFileEntry* file_entry = id_it->second.get();
int old_sequence_number = file_entry->sequence_number;
#if BUILDFLAG(IS_CHROMEOS_ASH)
// crbug.com/983844 Convert path from legacy Download/ to MyFiles/Downloads/
// so entries saved before MyFiles don't fail. TODO(lucmult): Remove this
// after M-83.
const auto legacy_downloads = context_->GetPath().AppendASCII("Downloads");
auto to_myfiles =
context_->GetPath().AppendASCII("MyFiles").AppendASCII("Downloads");
if (legacy_downloads.AppendRelativePath(file_entry->path, &to_myfiles))
file_entry->path = to_myfiles;
#endif
if (!saved_file_lru_.empty()) {
// Get the sequence number after the last file entry in the LRU.
std::map<int, SavedFileEntry*>::reverse_iterator it =
saved_file_lru_.rbegin();
if (it->second == file_entry)
return;
file_entry->sequence_number = it->first + 1;
} else {
// The first sequence number is 1, as 0 means the entry is not in the LRU.
file_entry->sequence_number = 1;
}
saved_file_lru_.insert(
std::make_pair(file_entry->sequence_number, file_entry));
ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
if (old_sequence_number) {
saved_file_lru_.erase(old_sequence_number);
UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
} else {
AddSavedFileEntry(prefs, extension_id_, *file_entry);
if (saved_file_lru_.size() > g_max_saved_file_entries) {
std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
it->second->sequence_number = 0;
RemoveSavedFileEntry(prefs, extension_id_, it->second->id);
saved_file_lru_.erase(it);
}
}
MaybeCompactSequenceNumbers();
}
bool SavedFilesService::SavedFiles::IsRegistered(const std::string& id) const {
auto it = registered_file_entries_.find(id);
return it != registered_file_entries_.end();
}
const SavedFileEntry* SavedFilesService::SavedFiles::GetFileEntry(
const std::string& id) const {
auto it = registered_file_entries_.find(id);
if (it == registered_file_entries_.end())
return NULL;
return it->second.get();
}
std::vector<SavedFileEntry> SavedFilesService::SavedFiles::GetAllFileEntries()
const {
std::vector<SavedFileEntry> result;
for (auto it = registered_file_entries_.begin();
it != registered_file_entries_.end(); ++it) {
result.push_back(*it->second.get());
}
return result;
}
void SavedFilesService::SavedFiles::MaybeCompactSequenceNumbers() {
DCHECK_GE(g_max_sequence_number, 0);
DCHECK_GE(static_cast<size_t>(g_max_sequence_number),
g_max_saved_file_entries);
std::map<int, SavedFileEntry*>::reverse_iterator last_it =
saved_file_lru_.rbegin();
if (last_it == saved_file_lru_.rend())
return;
// Only compact sequence numbers if the last entry's sequence number is the
// maximum value. This should almost never be the case.
if (last_it->first < g_max_sequence_number)
return;
int sequence_number = 0;
ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
for (std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
it != saved_file_lru_.end();
++it) {
sequence_number++;
if (it->second->sequence_number == sequence_number)
continue;
SavedFileEntry* file_entry = it->second;
file_entry->sequence_number = sequence_number;
UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
saved_file_lru_.erase(it++);
// Provide the following element as an insert hint. While optimized
// insertion time with the following element as a hint is only supported by
// the spec in C++11, the implementations do support this.
it = saved_file_lru_.insert(
it, std::make_pair(file_entry->sequence_number, file_entry));
}
}
void SavedFilesService::SavedFiles::LoadSavedFileEntriesFromPreferences() {
ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
std::vector<SavedFileEntry> saved_entries =
GetSavedFileEntries(prefs, extension_id_);
for (std::vector<SavedFileEntry>::iterator it = saved_entries.begin();
it != saved_entries.end();
++it) {
std::unique_ptr<SavedFileEntry> file_entry(new SavedFileEntry(*it));
const std::string& id = file_entry->id;
saved_file_lru_.insert(
std::make_pair(file_entry->sequence_number, file_entry.get()));
registered_file_entries_[id] = std::move(file_entry);
}
}
// static
void SavedFilesService::SetMaxSequenceNumberForTest(int max_value) {
g_max_sequence_number = max_value;
}
// static
void SavedFilesService::ClearMaxSequenceNumberForTest() {
g_max_sequence_number = kMaxSequenceNumber;
}
// static
void SavedFilesService::SetLruSizeForTest(int size) {
g_max_saved_file_entries = size;
}
// static
void SavedFilesService::ClearLruSizeForTest() {
g_max_saved_file_entries = kMaxSavedFileEntries;
}
} // namespace apps