1 // Copyright 2013 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "apps/saved_files_service.h"
12 #include <unordered_map>
15 #include "apps/saved_files_service_factory.h"
16 #include "base/json/values_util.h"
17 #include "base/memory/raw_ptr.h"
18 #include "build/chromeos_buildflags.h"
19 #include "content/public/browser/browser_context.h"
20 #include "extensions/browser/api/file_system/saved_file_entry.h"
21 #include "extensions/browser/extension_host.h"
22 #include "extensions/browser/extension_prefs.h"
23 #include "extensions/browser/extension_system.h"
24 #include "extensions/common/extension_id.h"
25 #include "extensions/common/permissions/api_permission.h"
26 #include "extensions/common/permissions/permission_set.h"
27 #include "extensions/common/permissions/permissions_data.h"
28 #include "third_party/abseil-cpp/absl/types/optional.h"
32 using extensions::APIPermission;
33 using extensions::Extension;
34 using extensions::ExtensionHost;
35 using extensions::ExtensionPrefs;
36 using extensions::SavedFileEntry;
42 // The file entries that the app has permission to access.
43 const char kFileEntries[] = "file_entries";
45 // The path to a file entry that the app had permission to access.
46 const char kFileEntryPath[] = "path";
48 // Whether or not the the entry refers to a directory.
49 const char kFileEntryIsDirectory[] = "is_directory";
51 // The sequence number in the LRU of the file entry.
52 const char kFileEntrySequenceNumber[] = "sequence_number";
54 const size_t kMaxSavedFileEntries = 500;
55 const int kMaxSequenceNumber = INT32_MAX;
57 // These might be different to the constant values in tests.
58 size_t g_max_saved_file_entries = kMaxSavedFileEntries;
59 int g_max_sequence_number = kMaxSequenceNumber;
61 // Persists a SavedFileEntry in ExtensionPrefs.
62 void AddSavedFileEntry(ExtensionPrefs* prefs,
63 const std::string& extension_id,
64 const SavedFileEntry& file_entry) {
65 ExtensionPrefs::ScopedDictionaryUpdate update(
66 prefs, extension_id, kFileEntries);
67 auto file_entries = update.Create();
69 !file_entries->GetDictionaryWithoutPathExpansion(file_entry.id, nullptr));
71 base::Value::Dict file_entry_dict;
72 file_entry_dict.Set(kFileEntryPath, base::FilePathToValue(file_entry.path));
73 file_entry_dict.Set(kFileEntryIsDirectory, file_entry.is_directory);
74 file_entry_dict.Set(kFileEntrySequenceNumber, file_entry.sequence_number);
75 file_entries->SetDictionaryWithoutPathExpansion(file_entry.id,
76 std::move(file_entry_dict));
79 // Updates the sequence_number of a SavedFileEntry persisted in ExtensionPrefs.
80 void UpdateSavedFileEntry(ExtensionPrefs* prefs,
81 const std::string& extension_id,
82 const SavedFileEntry& file_entry) {
83 ExtensionPrefs::ScopedDictionaryUpdate update(
84 prefs, extension_id, kFileEntries);
85 auto file_entries = update.Get();
87 std::unique_ptr<prefs::DictionaryValueUpdate> file_entry_dict;
88 file_entries->GetDictionaryWithoutPathExpansion(file_entry.id,
90 DCHECK(file_entry_dict);
91 file_entry_dict->SetInteger(kFileEntrySequenceNumber,
92 file_entry.sequence_number);
95 // Removes a SavedFileEntry from ExtensionPrefs.
96 void RemoveSavedFileEntry(ExtensionPrefs* prefs,
97 const std::string& extension_id,
98 const std::string& file_entry_id) {
99 ExtensionPrefs::ScopedDictionaryUpdate update(
100 prefs, extension_id, kFileEntries);
101 auto file_entries = update.Create();
102 file_entries->RemoveWithoutPathExpansion(file_entry_id, NULL);
105 // Clears all SavedFileEntry for the app from ExtensionPrefs.
106 void ClearSavedFileEntries(ExtensionPrefs* prefs,
107 const std::string& extension_id) {
108 prefs->UpdateExtensionPref(extension_id, kFileEntries, absl::nullopt);
111 // Returns all SavedFileEntries for the app.
112 std::vector<SavedFileEntry> GetSavedFileEntries(
113 ExtensionPrefs* prefs,
114 const std::string& extension_id) {
115 std::vector<SavedFileEntry> result;
117 const auto* dict = prefs->ReadPrefAsDict(extension_id, kFileEntries);
122 for (const auto item : *dict) {
123 const auto* file_entry = item.second.GetIfDict();
127 const base::Value* path_value = file_entry->Find(kFileEntryPath);
130 absl::optional<base::FilePath> file_path =
131 base::ValueToFilePath(*path_value);
135 file_entry->FindBool(kFileEntryIsDirectory).value_or(false);
136 const absl::optional<int> sequence_number =
137 file_entry->FindInt(kFileEntrySequenceNumber);
138 if (!sequence_number || sequence_number.value() == 0)
140 result.emplace_back(item.first, *file_path, is_directory,
141 sequence_number.value());
148 class SavedFilesService::SavedFiles {
150 SavedFiles(content::BrowserContext* context, const std::string& extension_id);
151 SavedFiles(const SavedFiles&) = delete;
152 SavedFiles& operator=(const SavedFiles&) = delete;
155 void RegisterFileEntry(const std::string& id,
156 const base::FilePath& file_path,
158 void EnqueueFileEntry(const std::string& id);
159 bool IsRegistered(const std::string& id) const;
160 const SavedFileEntry* GetFileEntry(const std::string& id) const;
161 std::vector<SavedFileEntry> GetAllFileEntries() const;
164 // Compacts sequence numbers if the largest sequence number is
165 // g_max_sequence_number. Outside of testing, it is set to kint32max, so this
166 // will almost never do any real work.
167 void MaybeCompactSequenceNumbers();
169 void LoadSavedFileEntriesFromPreferences();
171 raw_ptr<content::BrowserContext> context_;
172 const extensions::ExtensionId extension_id_;
174 // Contains all file entries that have been registered, keyed by ID.
175 std::unordered_map<std::string, std::unique_ptr<SavedFileEntry>>
176 registered_file_entries_;
178 // The queue of file entries that have been retained, keyed by
179 // sequence_number. Values are a subset of values in registered_file_entries_.
180 // This should be kept in sync with file entries stored in extension prefs.
181 std::map<int, SavedFileEntry*> saved_file_lru_;
185 SavedFilesService* SavedFilesService::Get(content::BrowserContext* context) {
186 return SavedFilesServiceFactory::GetForBrowserContext(context);
189 SavedFilesService::SavedFilesService(content::BrowserContext* context)
190 : context_(context) {
191 extension_host_registry_observation_.Observe(
192 extensions::ExtensionHostRegistry::Get(context_));
195 SavedFilesService::~SavedFilesService() = default;
197 void SavedFilesService::OnExtensionHostDestroyed(
198 content::BrowserContext* browser_context,
199 extensions::ExtensionHost* host) {
200 const Extension* extension = host->extension();
202 ClearQueueIfNoRetainPermission(extension);
203 Clear(extension->id());
207 void SavedFilesService::RegisterFileEntry(const std::string& extension_id,
208 const std::string& id,
209 const base::FilePath& file_path,
211 GetOrInsert(extension_id)->RegisterFileEntry(id, file_path, is_directory);
214 void SavedFilesService::EnqueueFileEntry(const std::string& extension_id,
215 const std::string& id) {
216 GetOrInsert(extension_id)->EnqueueFileEntry(id);
219 std::vector<SavedFileEntry> SavedFilesService::GetAllFileEntries(
220 const std::string& extension_id) {
221 SavedFiles* saved_files = Get(extension_id);
223 return saved_files->GetAllFileEntries();
224 return GetSavedFileEntries(ExtensionPrefs::Get(context_), extension_id);
227 bool SavedFilesService::IsRegistered(const std::string& extension_id,
228 const std::string& id) {
229 return GetOrInsert(extension_id)->IsRegistered(id);
232 const SavedFileEntry* SavedFilesService::GetFileEntry(
233 const std::string& extension_id,
234 const std::string& id) {
235 return GetOrInsert(extension_id)->GetFileEntry(id);
238 void SavedFilesService::ClearQueueIfNoRetainPermission(
239 const Extension* extension) {
240 if (!extension->permissions_data()->active_permissions().HasAPIPermission(
241 extensions::mojom::APIPermissionID::kFileSystemRetainEntries)) {
242 ClearQueue(extension);
246 void SavedFilesService::ClearQueue(const extensions::Extension* extension) {
247 ClearSavedFileEntries(ExtensionPrefs::Get(context_), extension->id());
248 Clear(extension->id());
251 void SavedFilesService::OnApplicationTerminating() {
252 // Stop listening to ExtensionHost shutdown as all extension hosts will be
253 // destroyed as a result of shutdown.
254 extension_host_registry_observation_.Reset();
257 SavedFilesService::SavedFiles* SavedFilesService::Get(
258 const std::string& extension_id) const {
259 auto it = extension_id_to_saved_files_.find(extension_id);
260 if (it != extension_id_to_saved_files_.end())
261 return it->second.get();
266 SavedFilesService::SavedFiles* SavedFilesService::GetOrInsert(
267 const std::string& extension_id) {
268 SavedFiles* saved_files = Get(extension_id);
272 std::unique_ptr<SavedFiles> scoped_saved_files(
273 new SavedFiles(context_, extension_id));
274 saved_files = scoped_saved_files.get();
275 extension_id_to_saved_files_.insert(
276 std::make_pair(extension_id, std::move(scoped_saved_files)));
280 void SavedFilesService::Clear(const std::string& extension_id) {
281 extension_id_to_saved_files_.erase(extension_id);
284 SavedFilesService::SavedFiles::SavedFiles(content::BrowserContext* context,
285 const std::string& extension_id)
286 : context_(context), extension_id_(extension_id) {
287 LoadSavedFileEntriesFromPreferences();
290 SavedFilesService::SavedFiles::~SavedFiles() = default;
292 void SavedFilesService::SavedFiles::RegisterFileEntry(
293 const std::string& id,
294 const base::FilePath& file_path,
296 auto it = registered_file_entries_.find(id);
297 if (it != registered_file_entries_.end())
300 registered_file_entries_[id] =
301 std::make_unique<SavedFileEntry>(id, file_path, is_directory, 0);
304 void SavedFilesService::SavedFiles::EnqueueFileEntry(const std::string& id) {
305 auto id_it = registered_file_entries_.find(id);
306 DCHECK(id_it != registered_file_entries_.end());
308 SavedFileEntry* file_entry = id_it->second.get();
309 int old_sequence_number = file_entry->sequence_number;
311 #if BUILDFLAG(IS_CHROMEOS_ASH)
312 // crbug.com/983844 Convert path from legacy Download/ to MyFiles/Downloads/
313 // so entries saved before MyFiles don't fail. TODO(lucmult): Remove this
315 const auto legacy_downloads = context_->GetPath().AppendASCII("Downloads");
317 context_->GetPath().AppendASCII("MyFiles").AppendASCII("Downloads");
318 if (legacy_downloads.AppendRelativePath(file_entry->path, &to_myfiles))
319 file_entry->path = to_myfiles;
322 if (!saved_file_lru_.empty()) {
323 // Get the sequence number after the last file entry in the LRU.
324 std::map<int, SavedFileEntry*>::reverse_iterator it =
325 saved_file_lru_.rbegin();
326 if (it->second == file_entry)
329 file_entry->sequence_number = it->first + 1;
331 // The first sequence number is 1, as 0 means the entry is not in the LRU.
332 file_entry->sequence_number = 1;
334 saved_file_lru_.insert(
335 std::make_pair(file_entry->sequence_number, file_entry));
336 ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
337 if (old_sequence_number) {
338 saved_file_lru_.erase(old_sequence_number);
339 UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
341 AddSavedFileEntry(prefs, extension_id_, *file_entry);
342 if (saved_file_lru_.size() > g_max_saved_file_entries) {
343 std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
344 it->second->sequence_number = 0;
345 RemoveSavedFileEntry(prefs, extension_id_, it->second->id);
346 saved_file_lru_.erase(it);
349 MaybeCompactSequenceNumbers();
352 bool SavedFilesService::SavedFiles::IsRegistered(const std::string& id) const {
353 auto it = registered_file_entries_.find(id);
354 return it != registered_file_entries_.end();
357 const SavedFileEntry* SavedFilesService::SavedFiles::GetFileEntry(
358 const std::string& id) const {
359 auto it = registered_file_entries_.find(id);
360 if (it == registered_file_entries_.end())
363 return it->second.get();
366 std::vector<SavedFileEntry> SavedFilesService::SavedFiles::GetAllFileEntries()
368 std::vector<SavedFileEntry> result;
369 for (auto it = registered_file_entries_.begin();
370 it != registered_file_entries_.end(); ++it) {
371 result.push_back(*it->second.get());
376 void SavedFilesService::SavedFiles::MaybeCompactSequenceNumbers() {
377 DCHECK_GE(g_max_sequence_number, 0);
378 DCHECK_GE(static_cast<size_t>(g_max_sequence_number),
379 g_max_saved_file_entries);
380 std::map<int, SavedFileEntry*>::reverse_iterator last_it =
381 saved_file_lru_.rbegin();
382 if (last_it == saved_file_lru_.rend())
385 // Only compact sequence numbers if the last entry's sequence number is the
386 // maximum value. This should almost never be the case.
387 if (last_it->first < g_max_sequence_number)
390 int sequence_number = 0;
391 ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
392 for (std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
393 it != saved_file_lru_.end();
396 if (it->second->sequence_number == sequence_number)
399 SavedFileEntry* file_entry = it->second;
400 file_entry->sequence_number = sequence_number;
401 UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
402 saved_file_lru_.erase(it++);
403 // Provide the following element as an insert hint. While optimized
404 // insertion time with the following element as a hint is only supported by
405 // the spec in C++11, the implementations do support this.
406 it = saved_file_lru_.insert(
407 it, std::make_pair(file_entry->sequence_number, file_entry));
411 void SavedFilesService::SavedFiles::LoadSavedFileEntriesFromPreferences() {
412 ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
413 std::vector<SavedFileEntry> saved_entries =
414 GetSavedFileEntries(prefs, extension_id_);
415 for (std::vector<SavedFileEntry>::iterator it = saved_entries.begin();
416 it != saved_entries.end();
418 std::unique_ptr<SavedFileEntry> file_entry(new SavedFileEntry(*it));
419 const std::string& id = file_entry->id;
420 saved_file_lru_.insert(
421 std::make_pair(file_entry->sequence_number, file_entry.get()));
422 registered_file_entries_[id] = std::move(file_entry);
427 void SavedFilesService::SetMaxSequenceNumberForTest(int max_value) {
428 g_max_sequence_number = max_value;
432 void SavedFilesService::ClearMaxSequenceNumberForTest() {
433 g_max_sequence_number = kMaxSequenceNumber;
437 void SavedFilesService::SetLruSizeForTest(int size) {
438 g_max_saved_file_entries = size;
442 void SavedFilesService::ClearLruSizeForTest() {
443 g_max_saved_file_entries = kMaxSavedFileEntries;