Integrate external mount points 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 28 matching lines @@
 #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;
+
+    default:
+      return true;
   }
   NOTREACHED();
   return true;
 }
 
 }
 
 static base::LazyInstance<IsolatedContext>::Leaky g_isolated_context =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 33 matching lines @@
 bool IsolatedContext::FileInfoSet::AddPathWithName(
     const FilePath& path, const std::string& name) {
   // 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;
 }
 
 //--------------------------------------------------------------------------
 
+class IsolatedContext::Instance {
+ public:
+  enum InstanceType {
+    ISOLATED,
+    EXTERNAL,
+  };
+
+  // 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);
+
+  // 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();
+
+  InstanceType instance_type() const { return instance_type_; }
+  FileSystemType type() const { return type_; }
+  const FileInfo& file_info() const { return file_info_; }
+  const std::set<FileInfo>& 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, FilePath* path) const;
+
+  // Returns true if the instance is a single-path instance.
+  bool IsSinglePathInstance() const;
+
+ private:
+  const InstanceType instance_type_;
+  const FileSystemType type_;
+
+  // For single-path instance.
+  const FileInfo file_info_;
+
+  // For multiple-path instance (e.g. dragged file system).
+  const std::set<FileInfo> 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 FileInfo& file_info)
-    : type_(type),
+    : instance_type_(ISOLATED),
+      type_(type),
       file_info_(file_info),
       ref_counts_(0) {
   DCHECK(IsSinglePathIsolatedFileSystem(type_));
 }
 
 IsolatedContext::Instance::Instance(FileSystemType type,
                                     const std::set<FileInfo>& files)
-    : type_(type),
+    : instance_type_(ISOLATED),
+      type_(type),
       files_(files),
       ref_counts_(0) {
   DCHECK(!IsSinglePathIsolatedFileSystem(type_));
 }
 
+IsolatedContext::Instance::Instance(FileSystemType type,
+                                    const FilePath& path)
+    : instance_type_(EXTERNAL),
+      type_(type),
+      file_info_(FileInfo("", path)),
+      ref_counts_(0) {
+  DCHECK(IsSinglePathIsolatedFileSystem(type_));
+}
+
 IsolatedContext::Instance::~Instance() {}
 
 bool IsolatedContext::Instance::ResolvePathForName(const std::string& name,
                                                    FilePath* path) const {
   if (IsSinglePathIsolatedFileSystem(type_)) {
     *path = file_info_.path;
     return file_info_.name == name;
   }
   std::set<FileInfo>::const_iterator found = files_.find(
       FileInfo(name, FilePath()));
   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();
 }
 
+// static
+bool IsolatedContext::IsIsolatedType(FileSystemType type) {
+  return type == kFileSystemTypeIsolated || type == kFileSystemTypeExternal;
+}
+
 std::string IsolatedContext::RegisterDraggedFileSystem(
     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(
@@ skipping 11 matching lines @@
       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;
 }
 
+#if defined(OS_CHROMEOS)
+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->instance_type() == Instance::EXTERNAL)
+      files.push_back(FileInfo(iter->first, iter->second->file_info().path));
+  }
+  return files;
+}
+#endif
+
 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())
@@ skipping 19 matching lines @@
 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(instance->ref_counts() > 0);
   instance->RemoveRef();
-  if (instance->ref_counts() == 0) {
+  if (instance->ref_counts() == 0 &&
+      instance->instance_type() != Instance::EXTERNAL) {
     bool deleted = UnregisterFileSystem(filesystem_id);
     DCHECK(deleted);
   }
 }
 
 bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
-                                        std::string* filesystem_id,
+                                        std::string* id_or_name,
                                         FileSystemType* type,
                                         FilePath* path) const {
-  DCHECK(filesystem_id);
+  DCHECK(id_or_name);
   DCHECK(path);
 
   // This should not contain any '..' references.
   if (virtual_path.ReferencesParent())
     return false;
 
-  // The virtual_path should comprise <filesystem_id> and <relative_path> parts.
+  // The virtual_path should comprise <id_or_name> and <relative_path> parts.
   std::vector<FilePath::StringType> components;
   virtual_path.GetComponents(&components);
   if (components.size() < 1)
     return false;
-
-  base::AutoLock locker(lock_);
-  std::string fsid = FilePath(components[0]).MaybeAsASCII();
+  std::vector<FilePath::StringType>::iterator component_iter =
+      components.begin();
+  std::string fsid = FilePath(*component_iter++).MaybeAsASCII();
   if (fsid.empty())
     return false;
-  IDToInstance::const_iterator found_instance = instance_map_.find(fsid);
-  if (found_instance == instance_map_.end())
-    return false;
-  *filesystem_id = fsid;
-  if (type)
-    *type = found_instance->second->type();
-  if (components.size() == 1) {
-    path->clear();
-    return true;
+
+  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();
+    switch (instance->instance_type()) {
+      case Instance::ISOLATED: {
+        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 Instance::EXTERNAL:
+        cracked_path = instance->file_info().path;
+        break;
+    }
   }
-  // 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]);
+  for (; component_iter != components.end(); ++component_iter)
+    cracked_path = cracked_path.Append(*component_iter);
   *path = cracked_path;
   return true;
 }
 
 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() ||
@@ skipping 53 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