[fsp] Store observed entries in preferences.

chrome/browser/chromeos/file_system_provider/service.cc

 // Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/service.h"
 
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
@@ skipping 22 matching lines @@
   DCHECK(profile);
   return new ProvidedFileSystem(profile, file_system_info);
 }
 
 }  // namespace
 
 const char kPrefKeyFileSystemId[] = "file-system-id";
 const char kPrefKeyDisplayName[] = "display-name";
 const char kPrefKeyWritable[] = "writable";
 const char kPrefKeySupportsNotifyTag[] = "supports-notify-tag";
+const char kPrefKeyObservedEntries[] = "observed-entries";
+const char kPrefKeyObservedEntryEntryPath[] = "entry-path";
+const char kPrefKeyObservedEntryRecursive[] = "recursive";
+const char kPrefKeyObservedEntryLastTag[] = "last-tag";
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
       prefs::kFileSystemProviderMounted,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 Service::Service(Profile* profile,
                  extensions::ExtensionRegistry* extension_registry)
     : profile_(profile),
@@ skipping 103 matching lines @@
   //   mount_path = /provided/b33f1337-hello_world-5aa5
   ProvidedFileSystemInfo file_system_info(extension_id, options, mount_path);
 
   ProvidedFileSystemInterface* file_system =
       file_system_factory_.Run(profile_, file_system_info);
   DCHECK(file_system);
   file_system_map_[FileSystemKey(extension_id, options.file_system_id)] =
       file_system;
   mount_point_name_to_key_map_[mount_point_name] =
       FileSystemKey(extension_id, options.file_system_id);
-  RememberFileSystem(file_system_info);
+  RememberFileSystem(file_system_info, *file_system->GetObservedEntries());
 
   FOR_EACH_OBSERVER(
       Observer,
       observers_,
       OnProvidedFileSystemMount(file_system_info, base::File::FILE_OK));
 
   return true;
 }
 
 bool Service::UnmountFileSystem(const std::string& extension_id,
@@ skipping 155 matching lines @@
     ChangeType change_type,
     const ChildChanges& child_changes,
     const base::Closure& callback) {
   callback.Run();
 }
 
 void Service::OnObservedEntryTagUpdated(
     const ProvidedFileSystemInfo& file_system_info,
     const base::FilePath& observed_path,
     const std::string& tag) {
-  // TODO(mtomasz): Store tags of observed entries in preferences, or better
-  // in leveldb.
+  PrefService* const pref_service = profile_->GetPrefs();
+  DCHECK(pref_service);
+
+  // TODO(mtomasz): Consider optimizing it by moving information about observed
+  // entries, or even file systems to leveldb.
+  DictionaryPrefUpdate dict_update(pref_service,
+                                   prefs::kFileSystemProviderMounted);
+
+  // All of the following checks should not happen in healthy environment.
+  // However, since they rely on storage, DCHECKs can't be used.
+  base::DictionaryValue* file_systems_per_extension = NULL;
+  base::DictionaryValue* file_system = NULL;
+  base::DictionaryValue* observed_entries = NULL;
+  base::DictionaryValue* observed_entry = NULL;
+  if (!dict_update->GetDictionaryWithoutPathExpansion(
+          file_system_info.extension_id(), &file_systems_per_extension) ||
+      !file_systems_per_extension->GetDictionaryWithoutPathExpansion(
+          file_system_info.file_system_id(), &file_system) ||
+      !file_system->GetDictionaryWithoutPathExpansion(kPrefKeyObservedEntries,
+                                                      &observed_entries) ||
+      !observed_entries->GetDictionaryWithoutPathExpansion(
+          observed_path.value(), &observed_entry)) {
+    // Broken preferences.
+    LOG(ERROR) << "Broken preferences detected while updating a tag.";
+    return;
+  }
+
+  observed_entry->SetStringWithoutPathExpansion(kPrefKeyObservedEntryLastTag,
+                                                tag);
 }
 
 void Service::OnObservedEntryListChanged(
     const ProvidedFileSystemInfo& file_system_info,
     const ObservedEntries& observed_entries) {
-  // TODO(mtomasz): Store observed entries in preferences or leveldb.
+  RememberFileSystem(file_system_info, observed_entries);
 }
 
-void Service::RememberFileSystem(
-    const ProvidedFileSystemInfo& file_system_info) {
-  base::DictionaryValue* file_system = new base::DictionaryValue();
+void Service::RememberFileSystem(const ProvidedFileSystemInfo& file_system_info,
+                                 const ObservedEntries& observed_entries) {
+  base::DictionaryValue* const file_system = new base::DictionaryValue();
   file_system->SetStringWithoutPathExpansion(kPrefKeyFileSystemId,
                                              file_system_info.file_system_id());
   file_system->SetStringWithoutPathExpansion(kPrefKeyDisplayName,
                                              file_system_info.display_name());
   file_system->SetBooleanWithoutPathExpansion(kPrefKeyWritable,
                                               file_system_info.writable());
   file_system->SetBooleanWithoutPathExpansion(
       kPrefKeySupportsNotifyTag, file_system_info.supports_notify_tag());
 
+  base::DictionaryValue* const observed_entries_value =
+      new base::DictionaryValue();
+  file_system->SetWithoutPathExpansion(kPrefKeyObservedEntries,
+                                       observed_entries_value);
+
+  for (ObservedEntries::const_iterator it = observed_entries.begin();
+       it != observed_entries.end();
+       ++it) {
+    base::DictionaryValue* const observed_entry = new base::DictionaryValue();
+    observed_entries_value->SetWithoutPathExpansion(it->first.value(),
+                                                    observed_entry);
+    observed_entry->SetStringWithoutPathExpansion(
+        kPrefKeyObservedEntryEntryPath, it->second.entry_path.value());
+    observed_entry->SetBooleanWithoutPathExpansion(
+        kPrefKeyObservedEntryRecursive, it->second.recursive);
+    observed_entry->SetStringWithoutPathExpansion(kPrefKeyObservedEntryLastTag,
+                                                  it->second.last_tag);
+  }
+
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);
 
   DictionaryPrefUpdate dict_update(pref_service,
                                    prefs::kFileSystemProviderMounted);
 
   base::DictionaryValue* file_systems_per_extension = NULL;
   if (!dict_update->GetDictionaryWithoutPathExpansion(
           file_system_info.extension_id(), &file_systems_per_extension)) {
     file_systems_per_extension = new base::DictionaryValue();
@@ skipping 64 matching lines @@
                                                     &display_name) ||
         !file_system->GetBooleanWithoutPathExpansion(kPrefKeyWritable,
                                                      &writable) ||
         !file_system->GetBooleanWithoutPathExpansion(kPrefKeySupportsNotifyTag,
                                                      &supports_notify_tag) ||
         file_system_id.empty() || display_name.empty()) {
       LOG(ERROR)
           << "Malformed provided file system information in preferences.";
       continue;
     }
+
     MountOptions options;
     options.file_system_id = file_system_id;
     options.display_name = display_name;
     options.writable = writable;
     options.supports_notify_tag = supports_notify_tag;
+
     const bool result = MountFileSystem(extension_id, options);
     if (!result) {
       LOG(ERROR) << "Failed to restore a provided file system from "
                  << "preferences: " << extension_id << ", " << file_system_id
                  << ", " << display_name << ".";
       // Since remounting of the file system failed, then remove it from
       // preferences to avoid remounting it over and over again with a failure.
       ForgetFileSystem(extension_id, file_system_id);
     }
+
+    // Restore observed entries. It's optional, since this field is new.
+    const base::DictionaryValue* observed_entries = NULL;
+    if (file_system->GetDictionaryWithoutPathExpansion(kPrefKeyObservedEntries,
+                                                       &observed_entries)) {
+      ProvidedFileSystemInterface* const restored_file_system =
+          GetProvidedFileSystem(extension_id, file_system_id);
+      DCHECK(restored_file_system);
+
+      for (base::DictionaryValue::Iterator it(*observed_entries); !it.IsAtEnd();
+           it.Advance()) {
+        const base::Value* observed_entry_value = NULL;
+        const base::DictionaryValue* observed_entry = NULL;
+        observed_entries->GetWithoutPathExpansion(it.key(),
+                                                  &observed_entry_value);
+        DCHECK(file_system_value);

[hirono, 2014/10/17 08:22:23]

nit: This check is redundant.

[mtomasz, 2014/10/20 05:11:56]

Why? GetWithoutPathExpansion may fail if the key is not found, and we would get
a NULL pointer here.

[hirono, 2014/10/20 05:18:49]

It looks the value has been already checked at #477.
DCHECK(observed_entry_value)?

[mtomasz, 2014/10/20 05:23:27]

You're right! Fixed.

+
+        std::string entry_path;
+        bool recursive = false;
+        std::string last_tag;
+
+        if (!observed_entry_value->GetAsDictionary(&observed_entry) ||
+            !observed_entry->GetStringWithoutPathExpansion(
+                kPrefKeyObservedEntryEntryPath, &entry_path) ||
+            !observed_entry->GetBooleanWithoutPathExpansion(
+                kPrefKeyObservedEntryRecursive, &recursive) ||
+            !observed_entry->GetStringWithoutPathExpansion(
+                kPrefKeyObservedEntryLastTag, &last_tag) ||
+            it.key() != entry_path || entry_path.empty() ||
+            (!options.supports_notify_tag && !last_tag.empty())) {
+          LOG(ERROR) << "Malformed observed entry information in preferences.";
+          continue;
+        }
+
+        ObservedEntry restored_observed_entry;
+        restored_observed_entry.entry_path =
+            base::FilePath::FromUTF8Unsafe(entry_path);
+        restored_observed_entry.recursive = recursive;
+        restored_observed_entry.last_tag = last_tag;
+        (*restored_file_system
+              ->GetObservedEntries())[restored_observed_entry.entry_path] =
+            restored_observed_entry;
+      }
+    }
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos