Add FileSystemID parameter to IsolatedContext::RegisterFileSystemForPath.

webkit/browser/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/browser/fileapi/isolated_context.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
@@ skipping 88 matching lines @@
  public:
   enum PathType {
     PLATFORM_PATH,
     VIRTUAL_PATH
   };
 
   // For a single-path isolated file system, which could be registered by
   // IsolatedContext::RegisterFileSystemForPath() or
   // IsolatedContext::RegisterFileSystemForVirtualPath().
   // Most of isolated file system contexts should be of this type.
-  Instance(FileSystemType type, const MountPointInfo& file_info,
+  Instance(FileSystemType type,
+           const std::string& filesystem_id,
+           const MountPointInfo& file_info,
            PathType path_type);
 
   // 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<MountPointInfo>& files);
 
   ~Instance();
 
   FileSystemType type() const { return type_; }
+  const std::string& filesystem_id() const { return filesystem_id_; }
   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_; }
   void RemoveRef() { --ref_counts_; }
 
   bool ResolvePathForName(const std::string& name, base::FilePath* path) const;
 
   // Returns true if the instance is a single-path instance.
   bool IsSinglePathInstance() const;
 
  private:
   const FileSystemType type_;
+  const std::string filesystem_id_;
 
   // For single-path instance.
   const MountPointInfo file_info_;
   const PathType path_type_;
 
   // For multiple-path instance (e.g. dragged file system).
   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.
   int ref_counts_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 IsolatedContext::Instance::Instance(FileSystemType type,
+                                    const std::string& filesystem_id,
                                     const MountPointInfo& file_info,
                                     Instance::PathType path_type)
     : type_(type),
+      filesystem_id_(filesystem_id),
       file_info_(file_info),
       path_type_(path_type),
       ref_counts_(0) {
   DCHECK(IsSinglePathIsolatedFileSystem(type_));
 }
 
 IsolatedContext::Instance::Instance(FileSystemType type,
                                     const std::set<MountPointInfo>& files)
     : type_(type),
       path_type_(PLATFORM_PATH),
@@ skipping 48 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 std::string& filesystem_id,
     const base::FilePath& path_in,
     std::string* register_name) {
   base::FilePath path(path_in.NormalizePathSeparators());
   if (path.ReferencesParent() || !path.IsAbsolute())
     return std::string();
   std::string name;
   if (register_name && !register_name->empty()) {
     name = *register_name;
   } else {
     name = base::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, MountPointInfo(name, path),
-                                              Instance::PLATFORM_PATH);
-  path_to_id_map_[path].insert(filesystem_id);
-  return filesystem_id;
+  std::string new_id = GetNewFileSystemId();
+  instance_map_[new_id] = new Instance(type, filesystem_id,
+                                       MountPointInfo(name, path),
+                                       Instance::PLATFORM_PATH);
+  path_to_id_map_[path].insert(new_id);
+  return new_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForVirtualPath(
     FileSystemType type,
     const std::string& register_name,
     const base::FilePath& cracked_path_prefix) {
   base::AutoLock locker(lock_);
   base::FilePath path(cracked_path_prefix.NormalizePathSeparators());
   if (path.ReferencesParent())
     return std::string();
   std::string filesystem_id = GetNewFileSystemId();
   instance_map_[filesystem_id] = new Instance(
       type,
+      std::string(),  // filesystem_id
       MountPointInfo(register_name, cracked_path_prefix),
       Instance::VIRTUAL_PATH);
   path_to_id_map_[path].insert(filesystem_id);
   return filesystem_id;
 }
 
 bool IsolatedContext::HandlesFileSystemMountType(FileSystemType type) const {
   return type == kFileSystemTypeIsolated;
 }
 
@@ skipping 10 matching lines @@
   if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
     return false;
   *path = found->second->file_info().path;
   return true;
 }
 
 bool IsolatedContext::CrackVirtualPath(
     const base::FilePath& virtual_path,
     std::string* id_or_name,
     FileSystemType* type,
+    std::string* cracked_id,
     base::FilePath* path,
     FileSystemMountOption* mount_option) const {
   DCHECK(id_or_name);
   DCHECK(path);
 
   // This should not contain any '..' references.
   if (virtual_path.ReferencesParent())
     return false;
 
   // Set the default mount option.
@@ skipping 13 matching lines @@
   base::FilePath cracked_path;
   {
     base::AutoLock locker(lock_);
     IDToInstance::const_iterator found_instance = instance_map_.find(fsid);
     if (found_instance == instance_map_.end())
       return false;
     *id_or_name = fsid;
     const Instance* instance = found_instance->second;
     if (type)
       *type = instance->type();
+    if (cracked_id)
+      *cracked_id = instance->filesystem_id();
 
     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 = base::FilePath(*component_iter++).AsUTF8Unsafe();
     if (!instance->ResolvePathForName(name, &cracked_path))
@@ skipping 86 matching lines @@
   STLDeleteContainerPairSecondPointers(instance_map_.begin(),
                                        instance_map_.end());
 }
 
 FileSystemURL IsolatedContext::CrackFileSystemURL(
     const FileSystemURL& url) const {
   if (!HandlesFileSystemMountType(url.type()))
     return FileSystemURL();
 
   std::string mount_name;
+  std::string cracked_mount_name;
   FileSystemType cracked_type;
   base::FilePath cracked_path;
   FileSystemMountOption cracked_mount_option;
   if (!CrackVirtualPath(url.path(), &mount_name, &cracked_type,
-                        &cracked_path, &cracked_mount_option)) {
+                        &cracked_mount_name, &cracked_path,
+                        &cracked_mount_option)) {
     return FileSystemURL();
   }
 
   return FileSystemURL(
       url.origin(), url.mount_type(), url.virtual_path(),
       !url.filesystem_id().empty() ? url.filesystem_id() : mount_name,
-      cracked_type, cracked_path, mount_name, cracked_mount_option);
+      cracked_type, cracked_path,
+      cracked_mount_name.empty() ? mount_name : cracked_mount_name,
+      cracked_mount_option);
 }
 
 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(
@@ skipping 14 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