Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(53)

Unified Diff: webkit/fileapi/isolated_context.cc

Issue 11648027: Extract external file systems handling from isolated context. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: gypi file Created 7 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: webkit/fileapi/isolated_context.cc
diff --git a/webkit/fileapi/isolated_context.cc b/webkit/fileapi/isolated_context.cc
index 057d508c6f993f5fa584700f9a903f5fbff125b3..1433e7240b2dcdcc6010b760f2586dbe46a70cd4 100644
--- a/webkit/fileapi/isolated_context.cc
+++ b/webkit/fileapi/isolated_context.cc
@@ -42,7 +42,7 @@ FilePath::StringType GetRegisterNameForPath(const FilePath& path) {
bool IsSinglePathIsolatedFileSystem(FileSystemType type) {
switch (type) {
// As of writing dragged file system is the only filesystem
- // which could have multiple toplevel paths.
+ // which could have multiple top-level paths.
case kFileSystemTypeDragged:
return false;
@@ -57,15 +57,10 @@ bool IsSinglePathIsolatedFileSystem(FileSystemType type) {
return true;
}
-} // namespace
-
static base::LazyInstance<IsolatedContext>::Leaky g_isolated_context =
LAZY_INSTANCE_INITIALIZER;
-IsolatedContext::FileInfo::FileInfo() {}
-IsolatedContext::FileInfo::FileInfo(
- const std::string& name, const FilePath& path)
- : name(name), path(path) {}
+} // namespace
IsolatedContext::FileInfoSet::FileInfoSet() {}
IsolatedContext::FileInfoSet::~FileInfoSet() {}
@@ -78,7 +73,8 @@ bool IsolatedContext::FileInfoSet::AddPath(
FilePath::StringType name = GetRegisterNameForPath(path);
std::string utf8name = FilePath(name).AsUTF8Unsafe();
FilePath normalized_path = path.NormalizePathSeparators();
- bool inserted = fileset_.insert(FileInfo(utf8name, normalized_path)).second;
+ bool inserted =
+ fileset_.insert(MountPointInfo(utf8name, normalized_path)).second;
if (!inserted) {
int suffix = 1;
std::string basepart = FilePath(name).RemoveExtension().AsUTF8Unsafe();
@@ -87,7 +83,8 @@ bool IsolatedContext::FileInfoSet::AddPath(
utf8name = base::StringPrintf("%s (%d)", basepart.c_str(), suffix++);
if (!ext.empty())
utf8name.append(ext);
- inserted = fileset_.insert(FileInfo(utf8name, normalized_path)).second;
+ inserted =
+ fileset_.insert(MountPointInfo(utf8name, normalized_path)).second;
}
}
if (registered_name)
@@ -100,34 +97,29 @@ bool IsolatedContext::FileInfoSet::AddPathWithName(
// The given path should not contain any '..' and should be absolute.
if (path.ReferencesParent() || !path.IsAbsolute())
return false;
- return fileset_.insert(FileInfo(name, path.NormalizePathSeparators())).second;
+ return fileset_.insert(
+ MountPointInfo(name, path.NormalizePathSeparators())).second;
}
//--------------------------------------------------------------------------
class IsolatedContext::Instance {
public:
- typedef FileSystemType MountType;
-
// For a single-path isolated file system, which could be registered by
// IsolatedContext::RegisterFileSystemForPath().
// Most of isolated file system contexts should be of this type.
- Instance(FileSystemType type, const FileInfo& file_info);
+ Instance(FileSystemType type, const MountPointInfo& file_info);
// For a multi-paths isolated file system. As of writing only file system
// type which could have multi-paths is Dragged file system, and
// could be registered by IsolatedContext::RegisterDraggedFileSystem().
- Instance(FileSystemType type, const std::set<FileInfo>& files);
-
- // For a single-path external file system.
- Instance(FileSystemType type, const FilePath& path);
+ Instance(FileSystemType type, const std::set<MountPointInfo>& files);
~Instance();
- MountType mount_type() const { return mount_type_; }
FileSystemType type() const { return type_; }
- const FileInfo& file_info() const { return file_info_; }
- const std::set<FileInfo>& files() const { return files_; }
+ const MountPointInfo& file_info() const { return file_info_; }
+ const std::set<MountPointInfo>& files() const { return files_; }
int ref_counts() const { return ref_counts_; }
void AddRef() { ++ref_counts_; }
@@ -139,14 +131,13 @@ class IsolatedContext::Instance {
bool IsSinglePathInstance() const;
private:
- const MountType mount_type_;
const FileSystemType type_;
// For single-path instance.
- const FileInfo file_info_;
+ const MountPointInfo file_info_;
// For multiple-path instance (e.g. dragged file system).
- const std::set<FileInfo> files_;
+ const std::set<MountPointInfo> files_;
// Reference counts. Note that an isolated filesystem is created with ref==0
// and will get deleted when the ref count reaches <=0.
@@ -156,32 +147,21 @@ class IsolatedContext::Instance {
};
IsolatedContext::Instance::Instance(FileSystemType type,
- const FileInfo& file_info)
- : mount_type_(kFileSystemTypeIsolated),
- type_(type),
+ const MountPointInfo& file_info)
+ : type_(type),
file_info_(file_info),
ref_counts_(0) {
DCHECK(IsSinglePathIsolatedFileSystem(type_));
}
IsolatedContext::Instance::Instance(FileSystemType type,
- const std::set<FileInfo>& files)
- : mount_type_(kFileSystemTypeIsolated),
- type_(type),
+ const std::set<MountPointInfo>& files)
+ : type_(type),
files_(files),
ref_counts_(0) {
DCHECK(!IsSinglePathIsolatedFileSystem(type_));
}
-IsolatedContext::Instance::Instance(FileSystemType type,
- const FilePath& path)
- : mount_type_(kFileSystemTypeExternal),
- type_(type),
- file_info_(FileInfo("", path)),
- ref_counts_(0) {
- DCHECK(IsSinglePathIsolatedFileSystem(type_));
-}
-
IsolatedContext::Instance::~Instance() {}
bool IsolatedContext::Instance::ResolvePathForName(const std::string& name,
@@ -190,8 +170,8 @@ bool IsolatedContext::Instance::ResolvePathForName(const std::string& name,
*path = file_info_.path;
return file_info_.name == name;
}
- std::set<FileInfo>::const_iterator found = files_.find(
- FileInfo(name, FilePath()));
+ std::set<MountPointInfo>::const_iterator found = files_.find(
+ MountPointInfo(name, FilePath()));
if (found == files_.end())
return false;
*path = found->path;
@@ -240,83 +220,28 @@ std::string IsolatedContext::RegisterFileSystemForPath(
base::AutoLock locker(lock_);
std::string filesystem_id = GetNewFileSystemId();
- instance_map_[filesystem_id] = new Instance(type, FileInfo(name, path));
+ instance_map_[filesystem_id] = new Instance(type, MountPointInfo(name, path));
path_to_id_map_[path].insert(filesystem_id);
return filesystem_id;
}
-bool IsolatedContext::RegisterExternalFileSystem(const std::string& mount_name,
- FileSystemType type,
- const FilePath& path) {
- base::AutoLock locker(lock_);
- IDToInstance::iterator found = instance_map_.find(mount_name);
- if (found != instance_map_.end())
- return false;
- instance_map_[mount_name] = new Instance(type, path);
- path_to_id_map_[path].insert(mount_name);
- return true;
-}
-
-std::vector<IsolatedContext::FileInfo>
-IsolatedContext::GetExternalMountPoints() const {
- base::AutoLock locker(lock_);
- std::vector<FileInfo> files;
- for (IDToInstance::const_iterator iter = instance_map_.begin();
- iter != instance_map_.end();
- ++iter) {
- if (iter->second->mount_type() == kFileSystemTypeExternal)
- files.push_back(FileInfo(iter->first, iter->second->file_info().path));
- }
- return files;
-}
-
bool IsolatedContext::RevokeFileSystem(const std::string& filesystem_id) {
base::AutoLock locker(lock_);
return UnregisterFileSystem(filesystem_id);
}
-void IsolatedContext::RevokeFileSystemByPath(const FilePath& path_in) {
- base::AutoLock locker(lock_);
- FilePath path(path_in.NormalizePathSeparators());
- PathToID::iterator ids_iter = path_to_id_map_.find(path);
- if (ids_iter == path_to_id_map_.end())
- return;
- std::set<std::string>& ids = ids_iter->second;
- for (std::set<std::string>::iterator iter = ids.begin();
- iter != ids.end(); ++iter) {
- IDToInstance::iterator found = instance_map_.find(*iter);
- if (found != instance_map_.end()) {
- delete found->second;
- instance_map_.erase(found);
- }
- }
- path_to_id_map_.erase(ids_iter);
-}
-
-void IsolatedContext::AddReference(const std::string& filesystem_id) {
- base::AutoLock locker(lock_);
- DCHECK(instance_map_.find(filesystem_id) != instance_map_.end());
- instance_map_[filesystem_id]->AddRef();
-}
-
-void IsolatedContext::RemoveReference(const std::string& filesystem_id) {
+bool IsolatedContext::GetRegisteredPath(
+ const std::string& filesystem_id, FilePath* path) const {
+ DCHECK(path);
base::AutoLock locker(lock_);
- // This could get called for non-existent filesystem if it has been
- // already deleted by RevokeFileSystemByPath.
- IDToInstance::iterator found = instance_map_.find(filesystem_id);
- if (found == instance_map_.end())
- return;
- Instance* instance = found->second;
- DCHECK_GT(instance->ref_counts(), 0);
- instance->RemoveRef();
- if (instance->ref_counts() == 0 &&
- instance->mount_type() != kFileSystemTypeExternal) {
- bool deleted = UnregisterFileSystem(filesystem_id);
- DCHECK(deleted);
- }
+ IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
+ if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
+ return false;
+ *path = found->second->file_info().path;
+ return true;
}
-bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
+bool IsolatedContext::CrackVirtualPath(const FilePath& virtual_path,
std::string* id_or_name,
FileSystemType* type,
FilePath* path) const {
@@ -348,26 +273,17 @@ bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
const Instance* instance = found_instance->second;
if (type)
*type = instance->type();
- switch (instance->mount_type()) {
- case kFileSystemTypeIsolated: {
- if (component_iter == components.end()) {
- // The virtual root case.
- path->clear();
- return true;
- }
- // *component_iter should be a name of the registered path.
- std::string name = FilePath(*component_iter++).AsUTF8Unsafe();
- if (!instance->ResolvePathForName(name, &cracked_path))
- return false;
- break;
- }
- case kFileSystemTypeExternal:
- cracked_path = instance->file_info().path;
- break;
- default:
- NOTREACHED();
- break;
+
+ if (component_iter == components.end()) {
+ // The virtual root case.
+ path->clear();
+ return true;
}
+
+ // *component_iter should be a name of the registered path.
+ std::string name = FilePath(*component_iter++).AsUTF8Unsafe();
+ if (!instance->ResolvePathForName(name, &cracked_path))
+ return false;
}
for (; component_iter != components.end(); ++component_iter)
@@ -376,8 +292,49 @@ bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
return true;
}
+void IsolatedContext::RevokeFileSystemByPath(const FilePath& path_in) {
+ base::AutoLock locker(lock_);
+ FilePath path(path_in.NormalizePathSeparators());
+ PathToID::iterator ids_iter = path_to_id_map_.find(path);
+ if (ids_iter == path_to_id_map_.end())
+ return;
+ std::set<std::string>& ids = ids_iter->second;
+ for (std::set<std::string>::iterator iter = ids.begin();
+ iter != ids.end(); ++iter) {
+ IDToInstance::iterator found = instance_map_.find(*iter);
+ if (found != instance_map_.end()) {
+ delete found->second;
+ instance_map_.erase(found);
+ }
+ }
+ path_to_id_map_.erase(ids_iter);
+}
+
+void IsolatedContext::AddReference(const std::string& filesystem_id) {
+ base::AutoLock locker(lock_);
+ DCHECK(instance_map_.find(filesystem_id) != instance_map_.end());
+ instance_map_[filesystem_id]->AddRef();
+}
+
+void IsolatedContext::RemoveReference(const std::string& filesystem_id) {
+ base::AutoLock locker(lock_);
+ // This could get called for non-existent filesystem if it has been
+ // already deleted by RevokeFileSystemByPath.
+ IDToInstance::iterator found = instance_map_.find(filesystem_id);
+ if (found == instance_map_.end())
+ return;
+ Instance* instance = found->second;
+ DCHECK_GT(instance->ref_counts(), 0);
+ instance->RemoveRef();
+ if (instance->ref_counts() == 0) {
+ bool deleted = UnregisterFileSystem(filesystem_id);
+ DCHECK(deleted);
+ }
+}
+
bool IsolatedContext::GetDraggedFileInfo(
- const std::string& filesystem_id, std::vector<FileInfo>* files) const {
+ const std::string& filesystem_id,
+ std::vector<MountPointInfo>* files) const {
DCHECK(files);
base::AutoLock locker(lock_);
IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
@@ -389,17 +346,6 @@ bool IsolatedContext::GetDraggedFileInfo(
return true;
}
-bool IsolatedContext::GetRegisteredPath(
- const std::string& filesystem_id, FilePath* path) const {
- DCHECK(path);
- base::AutoLock locker(lock_);
- IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
- if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
- return false;
- *path = found->second->file_info().path;
- return true;
-}
-
FilePath IsolatedContext::CreateVirtualRootPath(
const std::string& filesystem_id) const {
return FilePath().AppendASCII(filesystem_id);
@@ -444,21 +390,4 @@ std::string IsolatedContext::GetNewFileSystemId() const {
return id;
}
-ScopedExternalFileSystem::ScopedExternalFileSystem(
- const std::string& mount_name,
- FileSystemType type,
- const FilePath& path)
- : mount_name_(mount_name) {
- IsolatedContext::GetInstance()->RegisterExternalFileSystem(
- mount_name, type, path);
-}
-
-FilePath ScopedExternalFileSystem::GetVirtualRootPath() const {
- return IsolatedContext::GetInstance()->CreateVirtualRootPath(mount_name_);
-}
-
-ScopedExternalFileSystem::~ScopedExternalFileSystem() {
- IsolatedContext::GetInstance()->RevokeFileSystem(mount_name_);
-}
-
} // namespace fileapi

Powered by Google App Engine
This is Rietveld 408576698