apps/saved_files_service.cc

   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.
   4
   5 #include "apps/saved_files_service.h"
   6
   7 #include <stdint.h>
   8
   9 #include <algorithm>
  10 #include <map>
  11 #include <memory>
  12 #include <unordered_map>
  13 #include <utility>
  14
  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"
  29
  30 namespace apps {
  31
  32 using extensions::APIPermission;
  33 using extensions::Extension;
  34 using extensions::ExtensionHost;
  35 using extensions::ExtensionPrefs;
  36 using extensions::SavedFileEntry;
  37
  38 namespace {
  39
  40 // Preference keys
  41
  42 // The file entries that the app has permission to access.
  43 const char kFileEntries[] = "file_entries";
  44
  45 // The path to a file entry that the app had permission to access.
  46 const char kFileEntryPath[] = "path";
  47
  48 // Whether or not the the entry refers to a directory.
  49 const char kFileEntryIsDirectory[] = "is_directory";
  50
  51 // The sequence number in the LRU of the file entry.
  52 const char kFileEntrySequenceNumber[] = "sequence_number";
  53
  54 const size_t kMaxSavedFileEntries = 500;
  55 const int kMaxSequenceNumber = INT32_MAX;
  56
  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;
  60
  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();
  68   DCHECK(
  69       !file_entries->GetDictionaryWithoutPathExpansion(file_entry.id, nullptr));
  70
  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));
  77 }
  78
  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();
  86   DCHECK(file_entries);
  87   std::unique_ptr<prefs::DictionaryValueUpdate> file_entry_dict;
  88   file_entries->GetDictionaryWithoutPathExpansion(file_entry.id,
  89                                                   &file_entry_dict);
  90   DCHECK(file_entry_dict);
  91   file_entry_dict->SetInteger(kFileEntrySequenceNumber,
  92                               file_entry.sequence_number);
  93 }
  94
  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);
 103 }
 104
 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);
 109 }
 110
 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;
 116
 117   const auto* dict = prefs->ReadPrefAsDict(extension_id, kFileEntries);
 118   if (!dict) {
 119     return result;
 120   }
 121
 122   for (const auto item : *dict) {
 123     const auto* file_entry = item.second.GetIfDict();
 124     if (!file_entry)
 125       continue;
 126
 127     const base::Value* path_value = file_entry->Find(kFileEntryPath);
 128     if (!path_value)
 129       continue;
 130     absl::optional<base::FilePath> file_path =
 131         base::ValueToFilePath(*path_value);
 132     if (!file_path)
 133       continue;
 134     bool is_directory =
 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)
 139       continue;
 140     result.emplace_back(item.first, *file_path, is_directory,
 141                         sequence_number.value());
 142   }
 143   return result;
 144 }
 145
 146 }  // namespace
 147
 148 class SavedFilesService::SavedFiles {
 149  public:
 150   SavedFiles(content::BrowserContext* context, const std::string& extension_id);
 151   SavedFiles(const SavedFiles&) = delete;
 152   SavedFiles& operator=(const SavedFiles&) = delete;
 153   ~SavedFiles();
 154
 155   void RegisterFileEntry(const std::string& id,
 156                          const base::FilePath& file_path,
 157                          bool is_directory);
 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;
 162
 163  private:
 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();
 168
 169   void LoadSavedFileEntriesFromPreferences();
 170
 171   raw_ptr<content::BrowserContext> context_;
 172   const extensions::ExtensionId extension_id_;
 173
 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_;
 177
 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_;
 182 };
 183
 184 // static
 185 SavedFilesService* SavedFilesService::Get(content::BrowserContext* context) {
 186   return SavedFilesServiceFactory::GetForBrowserContext(context);
 187 }
 188
 189 SavedFilesService::SavedFilesService(content::BrowserContext* context)
 190     : context_(context) {
 191   extension_host_registry_observation_.Observe(
 192       extensions::ExtensionHostRegistry::Get(context_));
 193 }
 194
 195 SavedFilesService::~SavedFilesService() = default;
 196
 197 void SavedFilesService::OnExtensionHostDestroyed(
 198     content::BrowserContext* browser_context,
 199     extensions::ExtensionHost* host) {
 200   const Extension* extension = host->extension();
 201   if (extension) {
 202     ClearQueueIfNoRetainPermission(extension);
 203     Clear(extension->id());
 204   }
 205 }
 206
 207 void SavedFilesService::RegisterFileEntry(const std::string& extension_id,
 208                                           const std::string& id,
 209                                           const base::FilePath& file_path,
 210                                           bool is_directory) {
 211   GetOrInsert(extension_id)->RegisterFileEntry(id, file_path, is_directory);
 212 }
 213
 214 void SavedFilesService::EnqueueFileEntry(const std::string& extension_id,
 215                                          const std::string& id) {
 216   GetOrInsert(extension_id)->EnqueueFileEntry(id);
 217 }
 218
 219 std::vector<SavedFileEntry> SavedFilesService::GetAllFileEntries(
 220     const std::string& extension_id) {
 221   SavedFiles* saved_files = Get(extension_id);
 222   if (saved_files)
 223     return saved_files->GetAllFileEntries();
 224   return GetSavedFileEntries(ExtensionPrefs::Get(context_), extension_id);
 225 }
 226
 227 bool SavedFilesService::IsRegistered(const std::string& extension_id,
 228                                      const std::string& id) {
 229   return GetOrInsert(extension_id)->IsRegistered(id);
 230 }
 231
 232 const SavedFileEntry* SavedFilesService::GetFileEntry(
 233     const std::string& extension_id,
 234     const std::string& id) {
 235   return GetOrInsert(extension_id)->GetFileEntry(id);
 236 }
 237
 238 void SavedFilesService::ClearQueueIfNoRetainPermission(
 239     const Extension* extension) {
 240   if (!extension->permissions_data()->active_permissions().HasAPIPermission(
 241           extensions::mojom::APIPermissionID::kFileSystemRetainEntries)) {
 242     ClearQueue(extension);
 243   }
 244 }
 245
 246 void SavedFilesService::ClearQueue(const extensions::Extension* extension) {
 247   ClearSavedFileEntries(ExtensionPrefs::Get(context_), extension->id());
 248   Clear(extension->id());
 249 }
 250
 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();
 255 }
 256
 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();
 262
 263   return NULL;
 264 }
 265
 266 SavedFilesService::SavedFiles* SavedFilesService::GetOrInsert(
 267     const std::string& extension_id) {
 268   SavedFiles* saved_files = Get(extension_id);
 269   if (saved_files)
 270     return saved_files;
 271
 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)));
 277   return saved_files;
 278 }
 279
 280 void SavedFilesService::Clear(const std::string& extension_id) {
 281   extension_id_to_saved_files_.erase(extension_id);
 282 }
 283
 284 SavedFilesService::SavedFiles::SavedFiles(content::BrowserContext* context,
 285                                           const std::string& extension_id)
 286     : context_(context), extension_id_(extension_id) {
 287   LoadSavedFileEntriesFromPreferences();
 288 }
 289
 290 SavedFilesService::SavedFiles::~SavedFiles() = default;
 291
 292 void SavedFilesService::SavedFiles::RegisterFileEntry(
 293     const std::string& id,
 294     const base::FilePath& file_path,
 295     bool is_directory) {
 296   auto it = registered_file_entries_.find(id);
 297   if (it != registered_file_entries_.end())
 298     return;
 299
 300   registered_file_entries_[id] =
 301       std::make_unique<SavedFileEntry>(id, file_path, is_directory, 0);
 302 }
 303
 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());
 307
 308   SavedFileEntry* file_entry = id_it->second.get();
 309   int old_sequence_number = file_entry->sequence_number;
 310
 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
 314   // after M-83.
 315   const auto legacy_downloads = context_->GetPath().AppendASCII("Downloads");
 316   auto to_myfiles =
 317       context_->GetPath().AppendASCII("MyFiles").AppendASCII("Downloads");
 318   if (legacy_downloads.AppendRelativePath(file_entry->path, &to_myfiles))
 319     file_entry->path = to_myfiles;
 320 #endif
 321
 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)
 327       return;
 328
 329     file_entry->sequence_number = it->first + 1;
 330   } else {
 331     // The first sequence number is 1, as 0 means the entry is not in the LRU.
 332     file_entry->sequence_number = 1;
 333   }
 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);
 340   } else {
 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);
 347     }
 348   }
 349   MaybeCompactSequenceNumbers();
 350 }
 351
 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();
 355 }
 356
 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())
 361     return NULL;
 362
 363   return it->second.get();
 364 }
 365
 366 std::vector<SavedFileEntry> SavedFilesService::SavedFiles::GetAllFileEntries()
 367     const {
 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());
 372   }
 373   return result;
 374 }
 375
 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())
 383     return;
 384
 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)
 388     return;
 389
 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();
 394        ++it) {
 395     sequence_number++;
 396     if (it->second->sequence_number == sequence_number)
 397       continue;
 398
 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));
 408   }
 409 }
 410
 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();
 417        ++it) {
 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);
 423   }
 424 }
 425
 426 // static
 427 void SavedFilesService::SetMaxSequenceNumberForTest(int max_value) {
 428   g_max_sequence_number = max_value;
 429 }
 430
 431 // static
 432 void SavedFilesService::ClearMaxSequenceNumberForTest() {
 433   g_max_sequence_number = kMaxSequenceNumber;
 434 }
 435
 436 // static
 437 void SavedFilesService::SetLruSizeForTest(int size) {
 438   g_max_saved_file_entries = size;
 439 }
 440
 441 // static
 442 void SavedFilesService::ClearLruSizeForTest() {
 443   g_max_saved_file_entries = kMaxSavedFileEntries;
 444 }
 445
 446 }  // namespace apps