kFileSystemTypeIsolated should be only used in the URL exposed to renderer

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 89 matching lines @@
   // 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:
-  typedef FileSystemMountType MountType;
+  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);
 
   // 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);
@@ skipping 29 matching lines @@
 
   // 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)
-    : mount_type_(kFileSystemMountTypeIsolated),
+    : mount_type_(kFileSystemTypeIsolated),
       type_(type),
       file_info_(file_info),
       ref_counts_(0) {
   DCHECK(IsSinglePathIsolatedFileSystem(type_));
 }
 
 IsolatedContext::Instance::Instance(FileSystemType type,
                                     const std::set<FileInfo>& files)
-    : mount_type_(kFileSystemMountTypeIsolated),
+    : mount_type_(kFileSystemTypeIsolated),
       type_(type),
       files_(files),
       ref_counts_(0) {
   DCHECK(!IsSinglePathIsolatedFileSystem(type_));
 }
 
 IsolatedContext::Instance::Instance(FileSystemType type,
                                     const FilePath& path)
-    : mount_type_(kFileSystemMountTypeExternal),
+    : 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,
                                                    FilePath* path) const {
@@ skipping 69 matching lines @@
   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() == kFileSystemMountTypeExternal)
+    if (iter->second->mount_type() == kFileSystemTypeExternal)
       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);
 }
@@ skipping 26 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 &&
-      instance->mount_type() != kFileSystemMountTypeExternal) {
+      instance->mount_type() != kFileSystemTypeExternal) {
     bool deleted = UnregisterFileSystem(filesystem_id);
     DCHECK(deleted);
   }
 }
 
 bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
                                         std::string* id_or_name,
                                         FileSystemType* type,
                                         FilePath* path) const {
   DCHECK(id_or_name);
@@ skipping 18 matching lines @@
   {
     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->mount_type()) {
-      case kFileSystemMountTypeIsolated: {
+      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 kFileSystemMountTypeExternal:
+      case kFileSystemTypeExternal:
         cracked_path = instance->file_info().path;
         break;
-      case kFileSystemMountTypeUnknown:
+      default:
         NOTREACHED();
         break;
     }
   }
 
   for (; component_iter != components.end(); ++component_iter)
     cracked_path = cracked_path.Append(*component_iter);
   *path = cracked_path;
   return true;
 }
@@ skipping 60 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