[fsp] Store mounted file systems 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"
 #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 "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 
 using content::BrowserThread;
 
 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. The |event_router| must not be
 // NULL.
 ProvidedFileSystemInterface* CreateProvidedFileSystem(
     extensions::EventRouter* event_router,
     const ProvidedFileSystemInfo& file_system_info) {
   DCHECK(event_router);
   return new ProvidedFileSystem(event_router, file_system_info);
 }
 
 }  // namespace
 
+void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterDictionaryPref(
+      prefs::kFSPMountedFileSystems,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
 Service::Service(Profile* profile,
                  extensions::ExtensionRegistry* extension_registry)
     : profile_(profile),
       extension_registry_(extension_registry),
       file_system_factory_(base::Bind(CreateProvidedFileSystem)),
       weak_ptr_factory_(this) {
   extension_registry_->AddObserver(this);
 }
 
 Service::~Service() {
   extension_registry_->RemoveObserver(this);
+  RememberFileSystems();
 
   ProvidedFileSystemMap::iterator it = file_system_map_.begin();
   while (it != file_system_map_.end()) {
     const std::string file_system_id =
         it->second->GetFileSystemInfo().file_system_id();
     const std::string extension_id =
         it->second->GetFileSystemInfo().extension_id();
     ++it;
     UnmountFileSystem(extension_id, file_system_id);
   }
@@ skipping 182 matching lines @@
   if (file_system_it == file_system_map_.end())
     return NULL;
 
   return file_system_it->second;
 }
 
 void Service::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
+  // If the reason is not a profile shutdown, then forget the mounted file
+  // systems from preferences.
+  if (reason != extensions::UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN)
+    ForgetFileSystems(extension->id());
+
   // Unmount all of the provided file systems associated with this extension.
   ProvidedFileSystemMap::iterator it = file_system_map_.begin();
   while (it != file_system_map_.end()) {
     const ProvidedFileSystemInfo& file_system_info =
         it->second->GetFileSystemInfo();
     // Advance the iterator beforehand, otherwise it will become invalidated
     // by the UnmountFileSystem() call.
     ++it;
     if (file_system_info.extension_id() == extension->id()) {
       bool result = UnmountFileSystem(file_system_info.extension_id(),
                                       file_system_info.file_system_id());
       DCHECK(result);
     }
   }
 }
 
+void Service::OnExtensionLoaded(content::BrowserContext* browser_context,
+                                const extensions::Extension* extension) {
+  RestoreFileSystems(extension->id());
+}
+
 ProvidedFileSystemInterface* Service::GetProvidedFileSystem(
     const std::string& mount_point_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   const MountPointNameToKeyMap::const_iterator mapping_it =
       mount_point_name_to_key_map_.find(mount_point_name);
   if (mapping_it == mount_point_name_to_key_map_.end())
     return NULL;
 
   const ProvidedFileSystemMap::const_iterator file_system_it =
@@ skipping 10 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::RememberFileSystems() {
+  base::DictionaryValue extensions;
+  const std::vector<ProvidedFileSystemInfo> file_system_info_list =
+      GetProvidedFileSystemInfoList();
+
+  for (std::vector<ProvidedFileSystemInfo>::const_iterator it =
+           file_system_info_list.begin();
+       it != file_system_info_list.end();
+       ++it) {
+    base::ListValue* file_systems = NULL;
+    if (!extensions.GetList(it->extension_id(), &file_systems)) {
+      file_systems = new base::ListValue();
+      extensions.Set(it->extension_id(), file_systems);
+    }
+
+    base::DictionaryValue* file_system = new base::DictionaryValue();
+    file_system->SetString("file_system_id", it->file_system_id());
+    file_system->SetString("file_system_name", it->file_system_name());

[hashimoto, 2014/05/26 08:35:38]

These keys should be constants.

[mtomasz, 2014/05/27 02:10:27]

Done.

+    file_systems->Append(file_system);
+  }
+
+  PrefService* pref_service = profile_->GetPrefs();
+  DCHECK(pref_service);
+  pref_service->Set(prefs::kFSPMountedFileSystems, extensions);

[hashimoto, 2014/05/26 08:35:38]

This overwrites the previously saved data.
Doesn't this result in erasing the mounted file systems when the device is
restarted twice, without loading the extension?

[mtomasz, 2014/05/27 02:10:27]

Yes, this basically remembers all *currently mounted* file systems, overriding
previous values. We don't want to remember file systems which failed to remount.

Shutdown can't happen before loading is finished, so there should be no
situation that RememberFileSystems() is called, before all installed extensions
are loaded.

[mtomasz, 2014/05/27 02:13:43]

This is because loading is synchronous. All installed extensions are loaded
synchronously in a loop. Hence, shutdown can't happen before all of them are
loaded.

+  pref_service->CommitPendingWrite();
+}
+
+void Service::ForgetFileSystems(const std::string& extension_id) {
+  PrefService* pref_service = profile_->GetPrefs();
+  DCHECK(pref_service);
+
+  DictionaryPrefUpdate update(pref_service, prefs::kFSPMountedFileSystems);
+  base::DictionaryValue* extensions = update.Get();
+  DCHECK(extensions);
+
+  extensions->Remove(extension_id, NULL);
+}
+
+void Service::RestoreFileSystems(const std::string& extension_id) {
+  PrefService* pref_service = profile_->GetPrefs();
+  DCHECK(pref_service);
+
+  const base::DictionaryValue* extensions =
+      pref_service->GetDictionary(prefs::kFSPMountedFileSystems);
+  DCHECK(extensions);
+
+  const base::ListValue* file_systems;

[hashimoto, 2014/05/26 08:35:38]

nit: Initialize this with NULL.

[mtomasz, 2014/05/27 02:10:27]

Done.

+
+  if (!extensions->GetList(extension_id, &file_systems))

[hashimoto, 2014/05/26 08:35:38]

Why other GetXXX calls are only DCHECKing the results while this line and L.385
abort on errors?

[mtomasz, 2014/05/27 01:13:14]

Extension doesn't need to be in preferences, eg. if it just got installed. In
such situation, we shouldn't crash, since it is not an error.

However, #374, #379 catch malformed preferences, so we should crash.

[hashimoto, 2014/05/27 11:29:24]

Then maybe we should emit LOG for empty file_system_id and file_system_name too?

[mtomasz, 2014/05/28 02:02:19]

Done.

+    return;
+
+  for (size_t i = 0; i < file_systems->GetSize(); ++i) {
+    const base::DictionaryValue* file_system = NULL;
+    file_systems->GetDictionary(i, &file_system);
+    DCHECK(file_system);
+
+    std::string file_system_id;
+    file_system->GetString("file_system_id", &file_system_id);
+    DCHECK(!file_system_id.empty());
+
+    std::string file_system_name;
+    file_system->GetString("file_system_name", &file_system_name);
+    DCHECK(!file_system_name.empty());
+
+    if (file_system_id.empty() || file_system_name.empty())
+      continue;
+
+    const bool result =
+        MountFileSystem(extension_id, file_system_id, file_system_name);
+    if (!result) {
+      LOG(ERROR) << "Failed to restore a provided file system from "
+                 << "preferences: " << extension_id << ", " << file_system_id
+                 << ", " << file_system_name << ".";
+    }
+  }
+}
+
 }  // namespace file_system_provider
 }  // namespace chromeos