Enables internal filesystem types via Isolated filesystems

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 163 matching lines @@
   DCHECK(found->second->ref_counts() > 0);
   found->second->RemoveRef();
   if (found->second->ref_counts() == 0) {
     delete found->second;
     instance_map_.erase(found);
   }
 }
 
 bool IsolatedContext::CrackIsolatedPath(const FilePath& virtual_path,
                                         std::string* filesystem_id,
-                                        FileInfo* root_info,
+                                        FileSystemType* type,
                                         FilePath* path) const {
   DCHECK(filesystem_id);
   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.
   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();
   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;
   }
   // 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;
-  if (root_info)
-    *root_info = FileInfo(name, cracked_path);
   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 36 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