[fsp] Add support for observing entries and notifying about changes.

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"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
-#include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 // Maximum number of file systems to be mounted in the same time, per profile.
 const size_t kMaxFileSystems = 16;
 
 // Default factory for provided file systems. |profile| must not be NULL.
 ProvidedFileSystemInterface* CreateProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info) {
   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";
 
 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 43 matching lines @@
 
 void Service::SetFileSystemFactoryForTesting(
     const FileSystemFactoryCallback& factory_callback) {
   DCHECK(!factory_callback.is_null());
   file_system_factory_ = factory_callback;
 }
 
 bool Service::MountFileSystem(const std::string& extension_id,
                               const std::string& file_system_id,
                               const std::string& display_name,
-                              bool writable) {
+                              bool writable,
+                              bool supports_notify_tag) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If already exists a file system provided by the same extension with this
   // id, then abort.
   if (GetProvidedFileSystem(extension_id, file_system_id)) {
     FOR_EACH_OBSERVER(Observer,
                       observers_,
                       OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                                 base::File::FILE_ERROR_EXISTS));
     return false;
@@ skipping 30 matching lines @@
                                   base::File::FILE_ERROR_INVALID_OPERATION));
     return false;
   }
 
   // Store the file system descriptor. Use the mount point name as the file
   // system provider file system id.
   // Examples:
   //   file_system_id = hello_world
   //   mount_point_name =  b33f1337-hello_world-5aa5
   //   writable = false
+  //   supports_notify_tag = false
   //   mount_path = /provided/b33f1337-hello_world-5aa5
-  ProvidedFileSystemInfo file_system_info(
-      extension_id, file_system_id, display_name, writable, mount_path);
+  ProvidedFileSystemInfo file_system_info(extension_id,
+                                          file_system_id,
+                                          display_name,
+                                          writable,
+                                          supports_notify_tag,
+                                          mount_path);
 
   ProvidedFileSystemInterface* file_system =
       file_system_factory_.Run(profile_, file_system_info);
   DCHECK(file_system);
   file_system_map_[FileSystemKey(extension_id, file_system_id)] = file_system;
   mount_point_name_to_key_map_[mount_point_name] =
       FileSystemKey(extension_id, file_system_id);
   RememberFileSystem(file_system_info);
 
   FOR_EACH_OBSERVER(
@@ skipping 150 matching lines @@
   // Notify observers about failure in unmounting, since mount() will not be
   // called by the provided file system. In case of success mount() will be
   // invoked, and observers notified, so there is no need to call them now.
   if (error != base::File::FILE_OK) {
     FOR_EACH_OBSERVER(Observer,
                       observers_,
                       OnProvidedFileSystemUnmount(file_system_info, error));
   }
 }
 
+void Service::OnObservedEntryChanged(
+    const ProvidedFileSystemInfo& file_system_info,
+    const base::FilePath& observed_path,
+    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) {
+  // TODO(mtomasz): Store tags of observed entries in preferences, or better
+  // in leveldb.
+}
+
+void Service::OnObservedEntryListChanged(
+    const ProvidedFileSystemInfo& file_system_info) {
+  // TODO(mtomasz): Store observed entries in preferences or leveldb.
+}
+
 void Service::RememberFileSystem(
     const ProvidedFileSystemInfo& file_system_info) {
   base::DictionaryValue* 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());
 
   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)) {
@@ skipping 18 matching lines @@
   if (!dict_update->GetDictionaryWithoutPathExpansion(
           extension_id, &file_systems_per_extension))
     return;  // Nothing to forget.
 
   file_systems_per_extension->RemoveWithoutPathExpansion(file_system_id, NULL);
   if (!file_systems_per_extension->size())
     dict_update->Remove(extension_id, NULL);
 }
 
 void Service::RestoreFileSystems(const std::string& extension_id) {
+  // TODO(mtomasz): Restore observed entries together with their tags.
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);
 
   const base::DictionaryValue* const file_systems =
       pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
   DCHECK(file_systems);
 
   const base::DictionaryValue* file_systems_per_extension = NULL;
   if (!file_systems->GetDictionaryWithoutPathExpansion(
-          extension_id, &file_systems_per_extension))
+          extension_id, &file_systems_per_extension)) {
     return;  // Nothing to restore.
+  }
 
   // Use a copy of the dictionary, since the original one may be modified while
   // iterating over it.
   scoped_ptr<const base::DictionaryValue> file_systems_per_extension_copy(
       file_systems_per_extension->DeepCopy());
 
   for (base::DictionaryValue::Iterator it(*file_systems_per_extension_copy);
        !it.IsAtEnd();
        it.Advance()) {
     const base::Value* file_system_value = NULL;
     const base::DictionaryValue* file_system = NULL;
     file_systems_per_extension_copy->GetWithoutPathExpansion(
         it.key(), &file_system_value);
     DCHECK(file_system_value);
 
     std::string file_system_id;
     std::string display_name;
-    bool writable;
+    bool writable = false;
+    bool supports_notify_tag = false;
 
     if (!file_system_value->GetAsDictionary(&file_system) ||
         !file_system->GetStringWithoutPathExpansion(kPrefKeyFileSystemId,
                                                     &file_system_id) ||
         !file_system->GetStringWithoutPathExpansion(kPrefKeyDisplayName,
                                                     &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;
     }
-
-    const bool result =
-        MountFileSystem(extension_id, file_system_id, display_name, writable);
+    const bool result = MountFileSystem(extension_id,
+                                        file_system_id,
+                                        display_name,
+                                        writable,
+                                        supports_notify_tag);
     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);
     }
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos