Add RevokeFileSystem back to IsolatedContext

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 148 matching lines @@
     const FileInfoSet& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
   instance_map_[filesystem_id] = new Instance(
       kFileSystemTypeDragged, files.fileset());
   return filesystem_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForPath(
     FileSystemType type,
-    const FilePath& path,
+    const FilePath& path_in,
     std::string* register_name) {
+  FilePath path(path_in.NormalizePathSeparators());
   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::RevokeFileSystemByPath(const FilePath& path) {
+bool IsolatedContext::RevokeFileSystem(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
+  return UnregisterFileSystem(filesystem_id);

[kinuko, 2012/08/13 09:20:26]

Changed the mysterious argument name to our usual one.

+}
+
+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);
@@ skipping 12 matching lines @@
   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(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 deleted = UnregisterFileSystem(filesystem_id);
+    DCHECK(deleted);
   }
 }
 
 bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
                                         std::string* filesystem_id,
                                         FileSystemType* type,
                                         FilePath* path) const {
   DCHECK(filesystem_id);
   DCHECK(path);
 
@@ skipping 19 matching lines @@
     *type = found_instance->second->type();
   if (components.size() == 1) {
     path->clear();
     return true;
   }
   // components[1] should be a name of the registered paths.
   FilePath cracked_path;
   std::string name = FilePath(components[1]).AsUTF8Unsafe();
   if (!found_instance->second->ResolvePathForName(name, &cracked_path))
     return false;
+
   for (size_t i = 2; i < components.size(); ++i)
     cracked_path = cracked_path.Append(components[i]);
   *path = cracked_path;
   return true;
 }
 
 bool IsolatedContext::GetDraggedFileInfo(
     const std::string& filesystem_id, std::vector<FileInfo>* files) const {
   DCHECK(files);
   base::AutoLock locker(lock_);
@@ skipping 23 matching lines @@
 }
 
 IsolatedContext::IsolatedContext() {
 }
 
 IsolatedContext::~IsolatedContext() {
   STLDeleteContainerPairSecondPointers(instance_map_.begin(),
                                        instance_map_.end());
 }
 
+bool IsolatedContext::UnregisterFileSystem(const std::string& filesystem_id) {
+  lock_.AssertAcquired();
+  IDToInstance::iterator found = instance_map_.find(filesystem_id);
+  if (found == instance_map_.end())
+    return false;
+  Instance* instance = found->second;
+  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 found->second;
+  instance_map_.erase(found);
+  return true;
+}
+
 std::string IsolatedContext::GetNewFileSystemId() const {
   // Returns an arbitrary random string which must be unique in the map.
+  lock_.AssertAcquired();
   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