1// Copyright 2013 The Chromium Authors. All rights reserved.
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 <algorithm>
8
9#include "apps/saved_files_service_factory.h"
10#include "base/basictypes.h"
11#include "base/containers/hash_tables.h"
12#include "base/value_conversions.h"
13#include "chrome/browser/chrome_notification_types.h"
14#include "chrome/browser/profiles/profile.h"
15#include "content/public/browser/notification_service.h"
16#include "extensions/browser/extension_host.h"
17#include "extensions/browser/extension_prefs.h"
18#include "extensions/browser/extension_system.h"
19#include "extensions/browser/extension_util.h"
20#include "extensions/browser/notification_types.h"
21#include "extensions/common/permissions/api_permission.h"
22#include "extensions/common/permissions/permission_set.h"
23#include "extensions/common/permissions/permissions_data.h"
24
25namespace apps {
26
27using extensions::APIPermission;
28using extensions::Extension;
29using extensions::ExtensionHost;
30using extensions::ExtensionPrefs;
31
32namespace {
33
34// Preference keys
35
36// The file entries that the app has permission to access.
37const char kFileEntries[] = "file_entries";
38
39// The path to a file entry that the app had permission to access.
40const char kFileEntryPath[] = "path";
41
42// Whether or not the the entry refers to a directory.
43const char kFileEntryIsDirectory[] = "is_directory";
44
45// The sequence number in the LRU of the file entry.
46const char kFileEntrySequenceNumber[] = "sequence_number";
47
48const size_t kMaxSavedFileEntries = 500;
49const int kMaxSequenceNumber = kint32max;
50
51// These might be different to the constant values in tests.
52size_t g_max_saved_file_entries = kMaxSavedFileEntries;
53int g_max_sequence_number = kMaxSequenceNumber;
54
55// Persists a SavedFileEntry in ExtensionPrefs.
56void AddSavedFileEntry(ExtensionPrefs* prefs,
57                       const std::string& extension_id,
58                       const SavedFileEntry& file_entry) {
59  ExtensionPrefs::ScopedDictionaryUpdate update(
60      prefs, extension_id, kFileEntries);
61  base::DictionaryValue* file_entries = update.Get();
62  if (!file_entries)
63    file_entries = update.Create();
64  DCHECK(!file_entries->GetDictionaryWithoutPathExpansion(file_entry.id, NULL));
65
66  base::DictionaryValue* file_entry_dict = new base::DictionaryValue();
67  file_entry_dict->Set(kFileEntryPath, CreateFilePathValue(file_entry.path));
68  file_entry_dict->SetBoolean(kFileEntryIsDirectory, file_entry.is_directory);
69  file_entry_dict->SetInteger(kFileEntrySequenceNumber,
70                              file_entry.sequence_number);
71  file_entries->SetWithoutPathExpansion(file_entry.id, file_entry_dict);
72}
73
74// Updates the sequence_number of a SavedFileEntry persisted in ExtensionPrefs.
75void UpdateSavedFileEntry(ExtensionPrefs* prefs,
76                          const std::string& extension_id,
77                          const SavedFileEntry& file_entry) {
78  ExtensionPrefs::ScopedDictionaryUpdate update(
79      prefs, extension_id, kFileEntries);
80  base::DictionaryValue* file_entries = update.Get();
81  DCHECK(file_entries);
82  base::DictionaryValue* file_entry_dict = NULL;
83  file_entries->GetDictionaryWithoutPathExpansion(file_entry.id,
84                                                  &file_entry_dict);
85  DCHECK(file_entry_dict);
86  file_entry_dict->SetInteger(kFileEntrySequenceNumber,
87                              file_entry.sequence_number);
88}
89
90// Removes a SavedFileEntry from ExtensionPrefs.
91void RemoveSavedFileEntry(ExtensionPrefs* prefs,
92                          const std::string& extension_id,
93                          const std::string& file_entry_id) {
94  ExtensionPrefs::ScopedDictionaryUpdate update(
95      prefs, extension_id, kFileEntries);
96  base::DictionaryValue* file_entries = update.Get();
97  if (!file_entries)
98    file_entries = update.Create();
99  file_entries->RemoveWithoutPathExpansion(file_entry_id, NULL);
100}
101
102// Clears all SavedFileEntry for the app from ExtensionPrefs.
103void ClearSavedFileEntries(ExtensionPrefs* prefs,
104                           const std::string& extension_id) {
105  prefs->UpdateExtensionPref(extension_id, kFileEntries, NULL);
106}
107
108// Returns all SavedFileEntries for the app.
109std::vector<SavedFileEntry> GetSavedFileEntries(
110    ExtensionPrefs* prefs,
111    const std::string& extension_id) {
112  std::vector<SavedFileEntry> result;
113  const base::DictionaryValue* file_entries = NULL;
114  if (!prefs->ReadPrefAsDictionary(extension_id, kFileEntries, &file_entries))
115    return result;
116
117  for (base::DictionaryValue::Iterator it(*file_entries); !it.IsAtEnd();
118       it.Advance()) {
119    const base::DictionaryValue* file_entry = NULL;
120    if (!it.value().GetAsDictionary(&file_entry))
121      continue;
122    const base::Value* path_value;
123    if (!file_entry->Get(kFileEntryPath, &path_value))
124      continue;
125    base::FilePath file_path;
126    if (!GetValueAsFilePath(*path_value, &file_path))
127      continue;
128    bool is_directory = false;
129    file_entry->GetBoolean(kFileEntryIsDirectory, &is_directory);
130    int sequence_number = 0;
131    if (!file_entry->GetInteger(kFileEntrySequenceNumber, &sequence_number))
132      continue;
133    if (!sequence_number)
134      continue;
135    result.push_back(
136        SavedFileEntry(it.key(), file_path, is_directory, sequence_number));
137  }
138  return result;
139}
140
141}  // namespace
142
143SavedFileEntry::SavedFileEntry() : is_directory(false), sequence_number(0) {}
144
145SavedFileEntry::SavedFileEntry(const std::string& id,
146                               const base::FilePath& path,
147                               bool is_directory,
148                               int sequence_number)
149    : id(id),
150      path(path),
151      is_directory(is_directory),
152      sequence_number(sequence_number) {}
153
154class SavedFilesService::SavedFiles {
155 public:
156  SavedFiles(Profile* profile, const std::string& extension_id);
157  ~SavedFiles();
158
159  void RegisterFileEntry(const std::string& id,
160                         const base::FilePath& file_path,
161                         bool is_directory);
162  void EnqueueFileEntry(const std::string& id);
163  bool IsRegistered(const std::string& id) const;
164  const SavedFileEntry* GetFileEntry(const std::string& id) const;
165  std::vector<SavedFileEntry> GetAllFileEntries() const;
166
167 private:
168  // Compacts sequence numbers if the largest sequence number is
169  // g_max_sequence_number. Outside of testing, it is set to kint32max, so this
170  // will almost never do any real work.
171  void MaybeCompactSequenceNumbers();
172
173  void LoadSavedFileEntriesFromPreferences();
174
175  Profile* profile_;
176  const std::string extension_id_;
177
178  // Contains all file entries that have been registered, keyed by ID. Owns
179  // values.
180  base::hash_map<std::string, SavedFileEntry*> registered_file_entries_;
181  STLValueDeleter<base::hash_map<std::string, SavedFileEntry*> >
182      registered_file_entries_deleter_;
183
184  // The queue of file entries that have been retained, keyed by
185  // sequence_number. Values are a subset of values in registered_file_entries_.
186  // This should be kept in sync with file entries stored in extension prefs.
187  std::map<int, SavedFileEntry*> saved_file_lru_;
188
189  DISALLOW_COPY_AND_ASSIGN(SavedFiles);
190};
191
192// static
193SavedFilesService* SavedFilesService::Get(Profile* profile) {
194  return SavedFilesServiceFactory::GetForProfile(profile);
195}
196
197SavedFilesService::SavedFilesService(Profile* profile)
198    : extension_id_to_saved_files_deleter_(&extension_id_to_saved_files_),
199      profile_(profile) {
200  registrar_.Add(this,
201                 extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
202                 content::NotificationService::AllSources());
203  registrar_.Add(this,
204                 chrome::NOTIFICATION_APP_TERMINATING,
205                 content::NotificationService::AllSources());
206}
207
208SavedFilesService::~SavedFilesService() {}
209
210void SavedFilesService::Observe(int type,
211                                const content::NotificationSource& source,
212                                const content::NotificationDetails& details) {
213  switch (type) {
214    case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
215      ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
216      const Extension* extension = host->extension();
217      if (extension) {
218        ClearQueueIfNoRetainPermission(extension);
219        Clear(extension->id());
220      }
221      break;
222    }
223
224    case chrome::NOTIFICATION_APP_TERMINATING: {
225      // Stop listening to NOTIFICATION_EXTENSION_HOST_DESTROYED in particular
226      // as all extension hosts will be destroyed as a result of shutdown.
227      registrar_.RemoveAll();
228      break;
229    }
230  }
231}
232
233void SavedFilesService::RegisterFileEntry(const std::string& extension_id,
234                                          const std::string& id,
235                                          const base::FilePath& file_path,
236                                          bool is_directory) {
237  GetOrInsert(extension_id)->RegisterFileEntry(id, file_path, is_directory);
238}
239
240void SavedFilesService::EnqueueFileEntry(const std::string& extension_id,
241                                         const std::string& id) {
242  GetOrInsert(extension_id)->EnqueueFileEntry(id);
243}
244
245std::vector<SavedFileEntry> SavedFilesService::GetAllFileEntries(
246    const std::string& extension_id) {
247  SavedFiles* saved_files = Get(extension_id);
248  if (saved_files)
249    return saved_files->GetAllFileEntries();
250  return GetSavedFileEntries(ExtensionPrefs::Get(profile_), extension_id);
251}
252
253bool SavedFilesService::IsRegistered(const std::string& extension_id,
254                                     const std::string& id) {
255  return GetOrInsert(extension_id)->IsRegistered(id);
256}
257
258const SavedFileEntry* SavedFilesService::GetFileEntry(
259    const std::string& extension_id,
260    const std::string& id) {
261  return GetOrInsert(extension_id)->GetFileEntry(id);
262}
263
264void SavedFilesService::ClearQueueIfNoRetainPermission(
265    const Extension* extension) {
266  if (extensions::util::IsEphemeralApp(extension->id(), profile_) ||
267      !extension->permissions_data()->active_permissions()->HasAPIPermission(
268          APIPermission::kFileSystemRetainEntries)) {
269    ClearQueue(extension);
270  }
271}
272
273void SavedFilesService::ClearQueue(const extensions::Extension* extension) {
274  ClearSavedFileEntries(ExtensionPrefs::Get(profile_), extension->id());
275  Clear(extension->id());
276}
277
278SavedFilesService::SavedFiles* SavedFilesService::Get(
279    const std::string& extension_id) const {
280  std::map<std::string, SavedFiles*>::const_iterator it =
281      extension_id_to_saved_files_.find(extension_id);
282  if (it != extension_id_to_saved_files_.end())
283    return it->second;
284
285  return NULL;
286}
287
288SavedFilesService::SavedFiles* SavedFilesService::GetOrInsert(
289    const std::string& extension_id) {
290  SavedFiles* saved_files = Get(extension_id);
291  if (saved_files)
292    return saved_files;
293
294  saved_files = new SavedFiles(profile_, extension_id);
295  extension_id_to_saved_files_.insert(
296      std::make_pair(extension_id, saved_files));
297  return saved_files;
298}
299
300void SavedFilesService::Clear(const std::string& extension_id) {
301  std::map<std::string, SavedFiles*>::iterator it =
302      extension_id_to_saved_files_.find(extension_id);
303  if (it != extension_id_to_saved_files_.end()) {
304    delete it->second;
305    extension_id_to_saved_files_.erase(it);
306  }
307}
308
309SavedFilesService::SavedFiles::SavedFiles(Profile* profile,
310                                          const std::string& extension_id)
311    : profile_(profile),
312      extension_id_(extension_id),
313      registered_file_entries_deleter_(&registered_file_entries_) {
314  LoadSavedFileEntriesFromPreferences();
315}
316
317SavedFilesService::SavedFiles::~SavedFiles() {}
318
319void SavedFilesService::SavedFiles::RegisterFileEntry(
320    const std::string& id,
321    const base::FilePath& file_path,
322    bool is_directory) {
323  if (ContainsKey(registered_file_entries_, id))
324    return;
325
326  registered_file_entries_.insert(
327      std::make_pair(id, new SavedFileEntry(id, file_path, is_directory, 0)));
328}
329
330void SavedFilesService::SavedFiles::EnqueueFileEntry(const std::string& id) {
331  base::hash_map<std::string, SavedFileEntry*>::iterator it =
332      registered_file_entries_.find(id);
333  DCHECK(it != registered_file_entries_.end());
334
335  SavedFileEntry* file_entry = it->second;
336  int old_sequence_number = file_entry->sequence_number;
337  if (!saved_file_lru_.empty()) {
338    // Get the sequence number after the last file entry in the LRU.
339    std::map<int, SavedFileEntry*>::reverse_iterator it =
340        saved_file_lru_.rbegin();
341    if (it->second == file_entry)
342      return;
343
344    file_entry->sequence_number = it->first + 1;
345  } else {
346    // The first sequence number is 1, as 0 means the entry is not in the LRU.
347    file_entry->sequence_number = 1;
348  }
349  saved_file_lru_.insert(
350      std::make_pair(file_entry->sequence_number, file_entry));
351  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
352  if (old_sequence_number) {
353    saved_file_lru_.erase(old_sequence_number);
354    UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
355  } else {
356    AddSavedFileEntry(prefs, extension_id_, *file_entry);
357    if (saved_file_lru_.size() > g_max_saved_file_entries) {
358      std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
359      it->second->sequence_number = 0;
360      RemoveSavedFileEntry(prefs, extension_id_, it->second->id);
361      saved_file_lru_.erase(it);
362    }
363  }
364  MaybeCompactSequenceNumbers();
365}
366
367bool SavedFilesService::SavedFiles::IsRegistered(const std::string& id) const {
368  return ContainsKey(registered_file_entries_, id);
369}
370
371const SavedFileEntry* SavedFilesService::SavedFiles::GetFileEntry(
372    const std::string& id) const {
373  base::hash_map<std::string, SavedFileEntry*>::const_iterator it =
374      registered_file_entries_.find(id);
375  if (it == registered_file_entries_.end())
376    return NULL;
377
378  return it->second;
379}
380
381std::vector<SavedFileEntry> SavedFilesService::SavedFiles::GetAllFileEntries()
382    const {
383  std::vector<SavedFileEntry> result;
384  for (base::hash_map<std::string, SavedFileEntry*>::const_iterator it =
385           registered_file_entries_.begin();
386       it != registered_file_entries_.end();
387       ++it) {
388    result.push_back(*it->second);
389  }
390  return result;
391}
392
393void SavedFilesService::SavedFiles::MaybeCompactSequenceNumbers() {
394  DCHECK_GE(g_max_sequence_number, 0);
395  DCHECK_GE(static_cast<size_t>(g_max_sequence_number),
396            g_max_saved_file_entries);
397  std::map<int, SavedFileEntry*>::reverse_iterator it =
398      saved_file_lru_.rbegin();
399  if (it == saved_file_lru_.rend())
400    return;
401
402  // Only compact sequence numbers if the last entry's sequence number is the
403  // maximum value.  This should almost never be the case.
404  if (it->first < g_max_sequence_number)
405    return;
406
407  int sequence_number = 0;
408  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
409  for (std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
410       it != saved_file_lru_.end();
411       ++it) {
412    sequence_number++;
413    if (it->second->sequence_number == sequence_number)
414      continue;
415
416    SavedFileEntry* file_entry = it->second;
417    file_entry->sequence_number = sequence_number;
418    UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
419    saved_file_lru_.erase(it++);
420    // Provide the following element as an insert hint. While optimized
421    // insertion time with the following element as a hint is only supported by
422    // the spec in C++11, the implementations do support this.
423    it = saved_file_lru_.insert(
424        it, std::make_pair(file_entry->sequence_number, file_entry));
425  }
426}
427
428void SavedFilesService::SavedFiles::LoadSavedFileEntriesFromPreferences() {
429  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
430  std::vector<SavedFileEntry> saved_entries =
431      GetSavedFileEntries(prefs, extension_id_);
432  for (std::vector<SavedFileEntry>::iterator it = saved_entries.begin();
433       it != saved_entries.end();
434       ++it) {
435    SavedFileEntry* file_entry = new SavedFileEntry(*it);
436    registered_file_entries_.insert(std::make_pair(file_entry->id, file_entry));
437    saved_file_lru_.insert(
438        std::make_pair(file_entry->sequence_number, file_entry));
439  }
440}
441
442// static
443void SavedFilesService::SetMaxSequenceNumberForTest(int max_value) {
444  g_max_sequence_number = max_value;
445}
446
447// static
448void SavedFilesService::ClearMaxSequenceNumberForTest() {
449  g_max_sequence_number = kMaxSequenceNumber;
450}
451
452// static
453void SavedFilesService::SetLruSizeForTest(int size) {
454  g_max_saved_file_entries = size;
455}
456
457// static
458void SavedFilesService::ClearLruSizeForTest() {
459  g_max_saved_file_entries = kMaxSavedFileEntries;
460}
461
462}  // namespace apps
463