chrome/browser/ash/file_system_provider/registry.cc - chromium/src.git - Git at Google

 // Copyright 2014 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/ash/file_system_provider/registry.h"

 #include <optional>
 #include <utility>

 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/ash/file_system_provider/mount_path_util.h"
 #include "chrome/browser/ash/file_system_provider/observer.h"
 #include "chrome/browser/ash/file_system_provider/provided_file_system.h"
 #include "chrome/browser/ash/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/ash/file_system_provider/service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "storage/browser/file_system/external_mount_points.h"

 namespace ash::file_system_provider {

 const char kPrefKeyFileSystemId[] = "file-system-id";
 const char kPrefKeyDisplayName[] = "display-name";
 const char kPrefKeyWritable[] = "writable";
 const char kPrefKeySupportsNotifyTag[] = "supports-notify-tag";
 const char kPrefKeyWatchers[] = "watchers";
 const char kPrefKeyWatcherEntryPath[] = "entry-path";
 const char kPrefKeyWatcherRecursive[] = "recursive";
 const char kPrefKeyWatcherLastTag[] = "last-tag";
 const char kPrefKeyWatcherPersistentOrigins[] = "persistent-origins";
 const char kPrefKeyOpenedFilesLimit[] = "opened-files-limit";

 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kFileSystemProviderMounted);
 }

 Registry::Registry(Profile* profile) : profile_(profile) {
 }

 Registry::~Registry() = default;

 void Registry::RememberFileSystem(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
   base::Value::Dict file_system;
   file_system.Set(kPrefKeyFileSystemId, file_system_info.file_system_id());
   file_system.Set(kPrefKeyDisplayName, file_system_info.display_name());
   file_system.Set(kPrefKeyWritable, file_system_info.writable());
   file_system.Set(kPrefKeySupportsNotifyTag,
                   file_system_info.supports_notify_tag());
   file_system.Set(kPrefKeyOpenedFilesLimit,
                   file_system_info.opened_files_limit());
   // We don't need to write and read "persistent" field (in MountOptions) to
   // and from preference because all filesystems which are remembered must be
   // persistent.

   base::Value::Dict watchers_dict;

   for (const auto& it : watchers) {
     base::Value::Dict watcher;
     watcher.Set(kPrefKeyWatcherEntryPath, it.second.entry_path.value());
     watcher.Set(kPrefKeyWatcherRecursive, it.second.recursive);
     watcher.Set(kPrefKeyWatcherLastTag, it.second.last_tag);
     base::Value::List persistent_origins_value;
     for (const auto& subscriber_it : it.second.subscribers) {
       // Only persistent subscribers should be stored in persistent storage.
       // Other ones should not be restired after a restart.
       if (subscriber_it.second.persistent) {
         persistent_origins_value.Append(subscriber_it.first.spec());
       }
     }
     watcher.Set(kPrefKeyWatcherPersistentOrigins,
                 std::move(persistent_origins_value));
     watchers_dict.Set(it.second.entry_path.value(), std::move(watcher));
   }
   file_system.Set(kPrefKeyWatchers, std::move(watchers_dict));

   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);

   ScopedDictPrefUpdate dict_update(pref_service,
                                    prefs::kFileSystemProviderMounted);

   base::Value::Dict* file_systems_per_extension =
       dict_update->EnsureDict(file_system_info.provider_id().ToString());
   file_systems_per_extension->Set(file_system_info.file_system_id(),
                                   std::move(file_system));
 }

 void Registry::ForgetFileSystem(const ProviderId& provider_id,
                                 const std::string& file_system_id) {
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);

   ScopedDictPrefUpdate dict_update(pref_service,
                                    prefs::kFileSystemProviderMounted);

   base::Value::Dict* file_systems_per_extension =
       dict_update->FindDict(provider_id.ToString());
   if (!file_systems_per_extension)
     return;  // Nothing to forget.

   file_systems_per_extension->Remove(file_system_id);
   if (file_systems_per_extension->empty())
     dict_update->Remove(provider_id.ToString());
 }

 std::unique_ptr<Registry::RestoredFileSystems> Registry::RestoreFileSystems(
     const ProviderId& provider_id) {
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);

   const base::Value::Dict& file_systems =
       pref_service->GetDict(prefs::kFileSystemProviderMounted);

   const base::Value::Dict* file_systems_per_extension =
       file_systems.FindDict(provider_id.ToString());
   if (!file_systems_per_extension) {
     return base::WrapUnique(new RestoredFileSystems);  // Nothing to restore.
   }

   std::unique_ptr<RestoredFileSystems> restored_file_systems(
       new RestoredFileSystems);

   for (const auto file_system_it : *file_systems_per_extension) {
     if (!file_system_it.second.is_dict()) {
       LOG(ERROR)
           << "Malformed provided file system information in preferences.";
       continue;
     }

     const base::Value::Dict& file_system = file_system_it.second.GetDict();

     const std::string* file_system_id =
         file_system.FindString(kPrefKeyFileSystemId);
     const std::string* display_name =
         file_system.FindString(kPrefKeyDisplayName);
     std::optional<bool> writable = file_system.FindBool(kPrefKeyWritable);
     std::optional<bool> supports_notify_tag =
         file_system.FindBool(kPrefKeySupportsNotifyTag);
     std::optional<int> opened_files_limit =
         file_system.FindInt(kPrefKeyOpenedFilesLimit);

     // TODO(mtomasz): Move opened files limit to the mandatory list above in
     // M42.
     if ((!file_system_id || !display_name || !writable ||
          !supports_notify_tag || file_system_id->empty() ||
          display_name->empty()) ||
         // Optional fields.
         (opened_files_limit.has_value() && opened_files_limit.value() < 0)) {
       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.value();
     options.supports_notify_tag = supports_notify_tag.value();
     options.opened_files_limit = opened_files_limit.value_or(0);

     RestoredFileSystem restored_file_system;
     restored_file_system.provider_id = provider_id;
     restored_file_system.options = options;

     // Restore watchers. It's optional, since this field is new.
     const base::Value::Dict* watchers = file_system.FindDict(kPrefKeyWatchers);
     if (watchers) {
       for (const auto watcher_it : *watchers) {
         if (!watcher_it.second.is_dict()) {
           LOG(ERROR) << "Malformed watcher information in preferences.";
           continue;
         }

         const base::Value::Dict& watcher = watcher_it.second.GetDict();

         const std::string* entry_path =
             watcher.FindString(kPrefKeyWatcherEntryPath);
         std::optional<bool> recursive =
             watcher.FindBool(kPrefKeyWatcherRecursive);
         const std::string* last_tag =
             watcher.FindString(kPrefKeyWatcherLastTag);
         const base::Value::List* persistent_origins =
             watcher.FindList(kPrefKeyWatcherPersistentOrigins);

         if (!entry_path || !recursive || !last_tag || !persistent_origins ||
             watcher_it.first != *entry_path || entry_path->empty() ||
             (!options.supports_notify_tag &&
              (!last_tag->empty() || persistent_origins->size()))) {
           LOG(ERROR) << "Malformed watcher information in preferences.";
           continue;
         }

         Watcher restored_watcher;
         restored_watcher.entry_path =
             base::FilePath::FromUTF8Unsafe(*entry_path);
         restored_watcher.recursive = recursive.value();
         restored_watcher.last_tag = *last_tag;
         for (const auto& persistent_origin : *persistent_origins) {
           if (!persistent_origin.is_string()) {
             LOG(ERROR) << "Malformed subscriber information in preferences.";
             continue;
           }
           const GURL origin_as_gurl(persistent_origin.GetString());
           restored_watcher.subscribers[origin_as_gurl].origin = origin_as_gurl;
           restored_watcher.subscribers[origin_as_gurl].persistent = true;
         }
         restored_file_system.watchers[WatcherKey(
             base::FilePath::FromUTF8Unsafe(*entry_path), recursive.value())] =
             restored_watcher;
       }
     }
     restored_file_systems->push_back(restored_file_system);
   }

   return restored_file_systems;
 }

 void Registry::UpdateWatcherTag(const ProvidedFileSystemInfo& file_system_info,
                                 const Watcher& watcher) {
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);

   // TODO(mtomasz): Consider optimizing it by moving information about watchers
   // or even file systems to leveldb.
   ScopedDictPrefUpdate 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::Value::Dict* file_systems_per_extension =
       dict_update->FindDict(file_system_info.provider_id().ToString());
   base::Value::Dict* file_system = nullptr;
   base::Value::Dict* watchers = nullptr;
   base::Value::Dict* watcher_value = nullptr;

   if (file_systems_per_extension) {
     file_system =
         file_systems_per_extension->FindDict(file_system_info.file_system_id());
   }
   if (file_system)
     watchers = file_system->FindDict(kPrefKeyWatchers);
   if (watchers)
     watcher_value = watchers->FindDict(watcher.entry_path.value());

   if (!watcher_value) {
     // Broken preferences.
     LOG(ERROR) << "Broken preferences detected while updating a tag.";
     return;
   }

   watcher_value->Set(kPrefKeyWatcherLastTag, watcher.last_tag);
 }

 }  // namespace ash::file_system_provider
	// Copyright 2014 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/ash/file_system_provider/registry.h"

	#include <optional>
	#include <utility>

	#include "base/files/file_path.h"
	#include "base/memory/ptr_util.h"
	#include "base/values.h"
	#include "chrome/browser/ash/file_system_provider/mount_path_util.h"
	#include "chrome/browser/ash/file_system_provider/observer.h"
	#include "chrome/browser/ash/file_system_provider/provided_file_system.h"
	#include "chrome/browser/ash/file_system_provider/provided_file_system_info.h"
	#include "chrome/browser/ash/file_system_provider/service_factory.h"
	#include "chrome/browser/profiles/profile.h"
	#include "chrome/common/pref_names.h"
	#include "components/pref_registry/pref_registry_syncable.h"
	#include "components/prefs/pref_service.h"
	#include "components/prefs/scoped_user_pref_update.h"
	#include "extensions/browser/extension_registry.h"
	#include "extensions/browser/extension_system.h"
	#include "storage/browser/file_system/external_mount_points.h"

	namespace ash::file_system_provider {

	const char kPrefKeyFileSystemId[] = "file-system-id";
	const char kPrefKeyDisplayName[] = "display-name";
	const char kPrefKeyWritable[] = "writable";
	const char kPrefKeySupportsNotifyTag[] = "supports-notify-tag";
	const char kPrefKeyWatchers[] = "watchers";
	const char kPrefKeyWatcherEntryPath[] = "entry-path";
	const char kPrefKeyWatcherRecursive[] = "recursive";
	const char kPrefKeyWatcherLastTag[] = "last-tag";
	const char kPrefKeyWatcherPersistentOrigins[] = "persistent-origins";
	const char kPrefKeyOpenedFilesLimit[] = "opened-files-limit";

	void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
	registry->RegisterDictionaryPref(prefs::kFileSystemProviderMounted);
	}

	Registry::Registry(Profile* profile) : profile_(profile) {
	}

	Registry::~Registry() = default;

	void Registry::RememberFileSystem(
	const ProvidedFileSystemInfo& file_system_info,
	const Watchers& watchers) {
	base::Value::Dict file_system;
	file_system.Set(kPrefKeyFileSystemId, file_system_info.file_system_id());
	file_system.Set(kPrefKeyDisplayName, file_system_info.display_name());
	file_system.Set(kPrefKeyWritable, file_system_info.writable());
	file_system.Set(kPrefKeySupportsNotifyTag,
	file_system_info.supports_notify_tag());
	file_system.Set(kPrefKeyOpenedFilesLimit,
	file_system_info.opened_files_limit());
	// We don't need to write and read "persistent" field (in MountOptions) to
	// and from preference because all filesystems which are remembered must be
	// persistent.

	base::Value::Dict watchers_dict;

	for (const auto& it : watchers) {
	base::Value::Dict watcher;
	watcher.Set(kPrefKeyWatcherEntryPath, it.second.entry_path.value());
	watcher.Set(kPrefKeyWatcherRecursive, it.second.recursive);
	watcher.Set(kPrefKeyWatcherLastTag, it.second.last_tag);
	base::Value::List persistent_origins_value;
	for (const auto& subscriber_it : it.second.subscribers) {
	// Only persistent subscribers should be stored in persistent storage.
	// Other ones should not be restired after a restart.
	if (subscriber_it.second.persistent) {
	persistent_origins_value.Append(subscriber_it.first.spec());
	}
	}
	watcher.Set(kPrefKeyWatcherPersistentOrigins,
	std::move(persistent_origins_value));
	watchers_dict.Set(it.second.entry_path.value(), std::move(watcher));
	}
	file_system.Set(kPrefKeyWatchers, std::move(watchers_dict));

	PrefService* const pref_service = profile_->GetPrefs();
	DCHECK(pref_service);

	ScopedDictPrefUpdate dict_update(pref_service,
	prefs::kFileSystemProviderMounted);

	base::Value::Dict* file_systems_per_extension =
	dict_update->EnsureDict(file_system_info.provider_id().ToString());
	file_systems_per_extension->Set(file_system_info.file_system_id(),
	std::move(file_system));
	}

	void Registry::ForgetFileSystem(const ProviderId& provider_id,
	const std::string& file_system_id) {
	PrefService* const pref_service = profile_->GetPrefs();
	DCHECK(pref_service);

	ScopedDictPrefUpdate dict_update(pref_service,
	prefs::kFileSystemProviderMounted);

	base::Value::Dict* file_systems_per_extension =
	dict_update->FindDict(provider_id.ToString());
	if (!file_systems_per_extension)
	return; // Nothing to forget.

	file_systems_per_extension->Remove(file_system_id);
	if (file_systems_per_extension->empty())
	dict_update->Remove(provider_id.ToString());
	}

	std::unique_ptr<Registry::RestoredFileSystems> Registry::RestoreFileSystems(
	const ProviderId& provider_id) {
	PrefService* const pref_service = profile_->GetPrefs();
	DCHECK(pref_service);

	const base::Value::Dict& file_systems =
	pref_service->GetDict(prefs::kFileSystemProviderMounted);

	const base::Value::Dict* file_systems_per_extension =
	file_systems.FindDict(provider_id.ToString());
	if (!file_systems_per_extension) {
	return base::WrapUnique(new RestoredFileSystems); // Nothing to restore.
	}

	std::unique_ptr<RestoredFileSystems> restored_file_systems(
	new RestoredFileSystems);

	for (const auto file_system_it : *file_systems_per_extension) {
	if (!file_system_it.second.is_dict()) {
	LOG(ERROR)
	<< "Malformed provided file system information in preferences.";
	continue;
	}

	const base::Value::Dict& file_system = file_system_it.second.GetDict();

	const std::string* file_system_id =
	file_system.FindString(kPrefKeyFileSystemId);
	const std::string* display_name =
	file_system.FindString(kPrefKeyDisplayName);
	std::optional<bool> writable = file_system.FindBool(kPrefKeyWritable);
	std::optional<bool> supports_notify_tag =
	file_system.FindBool(kPrefKeySupportsNotifyTag);
	std::optional<int> opened_files_limit =
	file_system.FindInt(kPrefKeyOpenedFilesLimit);

	// TODO(mtomasz): Move opened files limit to the mandatory list above in
	// M42.
	if ((!file_system_id \|\| !display_name \|\| !writable \|\|
	!supports_notify_tag \|\| file_system_id->empty() \|\|
	display_name->empty()) \|\|
	// Optional fields.
	(opened_files_limit.has_value() && opened_files_limit.value() < 0)) {
	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.value();
	options.supports_notify_tag = supports_notify_tag.value();
	options.opened_files_limit = opened_files_limit.value_or(0);

	RestoredFileSystem restored_file_system;
	restored_file_system.provider_id = provider_id;
	restored_file_system.options = options;

	// Restore watchers. It's optional, since this field is new.
	const base::Value::Dict* watchers = file_system.FindDict(kPrefKeyWatchers);
	if (watchers) {
	for (const auto watcher_it : *watchers) {
	if (!watcher_it.second.is_dict()) {
	LOG(ERROR) << "Malformed watcher information in preferences.";
	continue;
	}

	const base::Value::Dict& watcher = watcher_it.second.GetDict();

	const std::string* entry_path =
	watcher.FindString(kPrefKeyWatcherEntryPath);
	std::optional<bool> recursive =
	watcher.FindBool(kPrefKeyWatcherRecursive);
	const std::string* last_tag =
	watcher.FindString(kPrefKeyWatcherLastTag);
	const base::Value::List* persistent_origins =
	watcher.FindList(kPrefKeyWatcherPersistentOrigins);

	if (!entry_path \|\| !recursive \|\| !last_tag \|\| !persistent_origins \|\|
	watcher_it.first != *entry_path \|\| entry_path->empty() \|\|
	(!options.supports_notify_tag &&
	(!last_tag->empty() \|\| persistent_origins->size()))) {
	LOG(ERROR) << "Malformed watcher information in preferences.";
	continue;
	}

	Watcher restored_watcher;
	restored_watcher.entry_path =
	base::FilePath::FromUTF8Unsafe(*entry_path);
	restored_watcher.recursive = recursive.value();
	restored_watcher.last_tag = *last_tag;
	for (const auto& persistent_origin : *persistent_origins) {
	if (!persistent_origin.is_string()) {
	LOG(ERROR) << "Malformed subscriber information in preferences.";
	continue;
	}
	const GURL origin_as_gurl(persistent_origin.GetString());
	restored_watcher.subscribers[origin_as_gurl].origin = origin_as_gurl;
	restored_watcher.subscribers[origin_as_gurl].persistent = true;
	}
	restored_file_system.watchers[WatcherKey(
	base::FilePath::FromUTF8Unsafe(*entry_path), recursive.value())] =
	restored_watcher;
	}
	}
	restored_file_systems->push_back(restored_file_system);
	}

	return restored_file_systems;
	}

	void Registry::UpdateWatcherTag(const ProvidedFileSystemInfo& file_system_info,
	const Watcher& watcher) {
	PrefService* const pref_service = profile_->GetPrefs();
	DCHECK(pref_service);

	// TODO(mtomasz): Consider optimizing it by moving information about watchers
	// or even file systems to leveldb.
	ScopedDictPrefUpdate 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::Value::Dict* file_systems_per_extension =
	dict_update->FindDict(file_system_info.provider_id().ToString());
	base::Value::Dict* file_system = nullptr;
	base::Value::Dict* watchers = nullptr;
	base::Value::Dict* watcher_value = nullptr;

	if (file_systems_per_extension) {
	file_system =
	file_systems_per_extension->FindDict(file_system_info.file_system_id());
	}
	if (file_system)
	watchers = file_system->FindDict(kPrefKeyWatchers);
	if (watchers)
	watcher_value = watchers->FindDict(watcher.entry_path.value());

	if (!watcher_value) {
	// Broken preferences.
	LOG(ERROR) << "Broken preferences detected while updating a tag.";
	return;
	}

	watcher_value->Set(kPrefKeyWatcherLastTag, watcher.last_tag);
	}

	} // namespace ash::file_system_provider