Add support for directory access to the file system API.

apps/saved_files_service.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // 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 <algorithm>
 
 #include "apps/saved_files_service_factory.h"
 #include "base/basictypes.h"
@@ skipping 18 matching lines @@
 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 = kint32max;
 
 // 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 std::string& extension_id,
                        const SavedFileEntry& file_entry) {
   ExtensionPrefs::ScopedDictionaryUpdate update(
       prefs, extension_id, kFileEntries);
   DictionaryValue* file_entries = update.Get();
   if (!file_entries)
     file_entries = update.Create();
   DCHECK(!file_entries->GetDictionaryWithoutPathExpansion(file_entry.id, NULL));
 
   DictionaryValue* file_entry_dict = new DictionaryValue();
   file_entry_dict->Set(kFileEntryPath, CreateFilePathValue(file_entry.path));
+  file_entry_dict->SetBoolean(kFileEntryIsDirectory, file_entry.is_directory);
   file_entry_dict->SetInteger(kFileEntrySequenceNumber,
                               file_entry.sequence_number);
   file_entries->SetWithoutPathExpansion(file_entry.id, file_entry_dict);
 }
 
 // Updates the sequence_number of a SavedFileEntry persisted in ExtensionPrefs.
 void UpdateSavedFileEntry(ExtensionPrefs* prefs,
                           const std::string& extension_id,
                           const SavedFileEntry& file_entry) {
   ExtensionPrefs::ScopedDictionaryUpdate update(
@@ skipping 39 matching lines @@
        it.Advance()) {
     const DictionaryValue* file_entry = NULL;
     if (!it.value().GetAsDictionary(&file_entry))
       continue;
     const base::Value* path_value;
     if (!file_entry->Get(kFileEntryPath, &path_value))
       continue;
     base::FilePath file_path;
     if (!GetValueAsFilePath(*path_value, &file_path))
       continue;
+    bool is_directory = false;
+    file_entry->GetBoolean(kFileEntryIsDirectory, &is_directory);
     int sequence_number = 0;
     if (!file_entry->GetInteger(kFileEntrySequenceNumber, &sequence_number))
       continue;
     if (!sequence_number)
       continue;
-    result.push_back(SavedFileEntry(it.key(), file_path, sequence_number));
+    result.push_back(
+        SavedFileEntry(it.key(), file_path, is_directory, sequence_number));
   }
   return result;
 }
 
 }  // namespace
 
-SavedFileEntry::SavedFileEntry() : sequence_number(0) {}
+SavedFileEntry::SavedFileEntry() : is_directory(false), sequence_number(0) {}
 
 SavedFileEntry::SavedFileEntry(const std::string& id,
                                const base::FilePath& path,
+                               bool is_directory,
                                int sequence_number)
     : id(id),
       path(path),
+      is_directory(is_directory),
       sequence_number(sequence_number) {}
 
 class SavedFilesService::SavedFiles {
  public:
   SavedFiles(Profile* profile, const std::string& extension_id);
   ~SavedFiles();
 
   void RegisterFileEntry(const std::string& id,
-                         const base::FilePath& file_path);
+                         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();
@@ skipping 53 matching lines @@
       // Stop listening to NOTIFICATION_EXTENSION_HOST_DESTROYED in particular
       // as all extension hosts will be destroyed as a result of shutdown.
       registrar_.RemoveAll();
       break;
     }
   }
 }
 
 void SavedFilesService::RegisterFileEntry(const std::string& extension_id,
                                           const std::string& id,
-                                          const base::FilePath& file_path) {
-  GetOrInsert(extension_id)->RegisterFileEntry(id, file_path);
+                                          const base::FilePath& file_path,
+                                          bool is_directory) {
+  GetOrInsert(extension_id)->RegisterFileEntry(id, file_path, is_directory);
 }
 
 void SavedFilesService::EnqueueFileEntry(const std::string& extension_id,
                                          const std::string& id) {
   GetOrInsert(extension_id)->EnqueueFileEntry(id);
 }
 
 std::vector<SavedFileEntry> SavedFilesService::GetAllFileEntries(
     const std::string& extension_id) {
   SavedFiles* saved_files = Get(extension_id);
@@ skipping 62 matching lines @@
     : profile_(profile),
       extension_id_(extension_id),
       registered_file_entries_deleter_(&registered_file_entries_) {
   LoadSavedFileEntriesFromPreferences();
 }
 
 SavedFilesService::SavedFiles::~SavedFiles() {}
 
 void SavedFilesService::SavedFiles::RegisterFileEntry(
     const std::string& id,
-    const base::FilePath& file_path) {
+    const base::FilePath& file_path,
+    bool is_directory) {
   if (ContainsKey(registered_file_entries_, id))
     return;
 
   registered_file_entries_.insert(
-      std::make_pair(id, new SavedFileEntry(id, file_path, 0)));
+      std::make_pair(id, new SavedFileEntry(id, file_path, is_directory, 0)));
 }
 
 void SavedFilesService::SavedFiles::EnqueueFileEntry(const std::string& id) {
   base::hash_map<std::string, SavedFileEntry*>::iterator it =
       registered_file_entries_.find(id);
   DCHECK(it != registered_file_entries_.end());
 
   SavedFileEntry* file_entry = it->second;
   int old_sequence_number = file_entry->sequence_number;
   if (!saved_file_lru_.empty()) {
@@ skipping 115 matching lines @@
 void SavedFilesService::SetLruSizeForTest(int size) {
   g_max_saved_file_entries = size;
 }
 
 // static
 void SavedFilesService::ClearLruSizeForTest() {
   g_max_saved_file_entries = kMaxSavedFileEntries;
 }
 
 }  // namespace apps