Adding RevokeFileSystemByPath

webkit/fileapi/isolated_context.cc

 // Copyright (c) 2012 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 "webkit/fileapi/isolated_context.h"
 
 #include "base/file_path.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
@@ skipping 21 matching lines @@
       break;
     }
     name.append(1, path.value()[i]);
   }
   return name;
 #else
   return FILE_PATH_LITERAL("<root>");
 #endif
 }
 
+bool IsSinglePathIsolatedFileSystem(FileSystemType type) {
+  switch (type) {
+    // As of writing dragged file system is the only filesystem
+    // which could have multiple toplevel paths.
+    case kFileSystemTypeDragged:
+      return false;
+
+    // Regular file systems.
+    case kFileSystemTypeIsolated:
+    case kFileSystemTypeNativeMedia:
+    case kFileSystemTypeDeviceMedia:
+    case kFileSystemTypeTemporary:
+    case kFileSystemTypePersistent:
+    case kFileSystemTypeExternal:
+    case kFileSystemTypeTest:
+      return true;
+
+    case kFileSystemTypeUnknown:
+      NOTREACHED();
+      return true;
+  }
+  NOTREACHED();
+  return true;
+}
+
 }
 
 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) {}
 
@@ skipping 32 matching lines @@
     return false;
   return fileset_.insert(FileInfo(name, path.NormalizePathSeparators())).second;
 }
 
 //--------------------------------------------------------------------------
 
 IsolatedContext::Instance::Instance(FileSystemType type,
                                     const FileInfo& file_info)
     : type_(type),
       file_info_(file_info),
-      ref_counts_(0) {}
+      ref_counts_(0) {
+  DCHECK(IsSinglePathIsolatedFileSystem(type_));
+}
 
-IsolatedContext::Instance::Instance(const std::set<FileInfo>& dragged_files)
-    : type_(kFileSystemTypeDragged),
-      dragged_files_(dragged_files),
-      ref_counts_(0) {}
+IsolatedContext::Instance::Instance(FileSystemType type,
+                                    const std::set<FileInfo>& files)
+    : type_(type),
+      files_(files),
+      ref_counts_(0) {
+  DCHECK(!IsSinglePathIsolatedFileSystem(type_));
+}
 
 IsolatedContext::Instance::~Instance() {}
 
 bool IsolatedContext::Instance::ResolvePathForName(const std::string& name,
-                                                   FilePath* path) {
-  if (type_ != kFileSystemTypeDragged) {
+                                                   FilePath* path) const {
+  if (IsSinglePathIsolatedFileSystem(type_)) {
     *path = file_info_.path;
     return file_info_.name == name;
   }
-  std::set<FileInfo>::const_iterator found = dragged_files_.find(
+  std::set<FileInfo>::const_iterator found = files_.find(
       FileInfo(name, FilePath()));
-  if (found == dragged_files_.end())
+  if (found == files_.end())
     return false;
   *path = found->path;
   return true;
 }
 
+bool IsolatedContext::Instance::IsSinglePathInstance() const {
+  return IsSinglePathIsolatedFileSystem(type_);
+}
+
 //--------------------------------------------------------------------------
 
 // static
 IsolatedContext* IsolatedContext::GetInstance() {
   return g_isolated_context.Pointer();
 }
 
 std::string IsolatedContext::RegisterDraggedFileSystem(
     const FileInfoSet& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(files.fileset());
+  instance_map_[filesystem_id] = new Instance(
+      kFileSystemTypeDragged, files.fileset());
   return filesystem_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForPath(
     FileSystemType type,
     const FilePath& path,
     std::string* register_name) {
   DCHECK(!path.ReferencesParent() && path.IsAbsolute());
   std::string name;
   if (register_name && !register_name->empty()) {
     name = *register_name;
   } else {
     name = FilePath(GetRegisterNameForPath(path)).AsUTF8Unsafe();
     if (register_name)
       register_name->assign(name);
   }
 
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
   instance_map_[filesystem_id] = new Instance(type, FileInfo(name, path));
+  path_to_id_map_[path].insert(filesystem_id);
   return filesystem_id;
 }
 
-void IsolatedContext::RevokeFileSystem(const std::string& filesystem_id) {
+void IsolatedContext::RevokeFileSystemByPath(const FilePath& path) {
   base::AutoLock locker(lock_);
-  IDToInstance::iterator found = instance_map_.find(filesystem_id);
-  if (found == instance_map_.end())
+  PathToID::iterator ids_iter = path_to_id_map_.find(path);
+  if (ids_iter == path_to_id_map_.end())
     return;
-  delete found->second;
-  instance_map_.erase(found);
+  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 RevokeFileSystem.
+  // already deleted by RevokeFileSystemByPath.
   IDToInstance::iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return;
-  DCHECK(found->second->ref_counts() > 0);
-  found->second->RemoveRef();
-  if (found->second->ref_counts() == 0) {
-    delete found->second;
+  Instance* instance = found->second;
+  DCHECK(instance->ref_counts() > 0);
+  instance->RemoveRef();
+  if (instance->ref_counts() == 0) {
+    if (instance->IsSinglePathInstance()) {
+      PathToID::iterator ids_iter = path_to_id_map_.find(
+          instance->file_info().path);
+      DCHECK(ids_iter != path_to_id_map_.end());
+      ids_iter->second.erase(filesystem_id);
+      if (ids_iter->second.empty())
+        path_to_id_map_.erase(ids_iter);
+    }
+    delete instance;
     instance_map_.erase(found);
   }
 }
 
 bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
                                         std::string* filesystem_id,
                                         FileSystemType* type,
                                         FilePath* path) const {
   DCHECK(filesystem_id);
   DCHECK(path);
@@ skipping 34 matching lines @@
 }
 
 bool IsolatedContext::GetDraggedFileInfo(
     const std::string& filesystem_id, std::vector<FileInfo>* files) const {
   DCHECK(files);
   base::AutoLock locker(lock_);
   IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() ||
       found->second->type() != kFileSystemTypeDragged)
     return false;
-  files->assign(found->second->dragged_files().begin(),
-                found->second->dragged_files().end());
+  files->assign(found->second->files().begin(),
+                found->second->files().end());
   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->type() == kFileSystemTypeDragged)
+  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);
 }
 
@@ skipping 10 matching lines @@
   uint32 random_data[4];
   std::string id;
   do {
     base::RandBytes(random_data, sizeof(random_data));
     id = base::HexEncode(random_data, sizeof(random_data));
   } while (instance_map_.find(id) != instance_map_.end());
   return id;
 }
 
 }  // namespace fileapi