New FileSystemURL cracking

webkit/fileapi/external_mount_points.cc

 // Copyright (c) 2013 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/external_mount_points.h"
 
 #include "base/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
+#include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/remote_file_system_proxy.h"
 
 namespace {
 
 // Normalizes file path so it has normalized separators and ends with exactly
 // one separator. Paths have to be normalized this way for use in
 // GetVirtualPath method. Separators cannot be completely stripped, or
 // GetVirtualPath could not working in some edge cases.
 // For example, /a/b/c(1)/d would be erroneously resolved as c/d if the
 // following mount points were registered: "/a/b/c", "/a/b/c(1)". (Note:
@@ skipping 126 matching lines @@
   FilePath path = NormalizeFilePath(path_in);
   if (!ValidateNewMountPoint(mount_name, path))
     return false;
 
   instance_map_[mount_name] = new Instance(type, path, remote_proxy);
   if (!path.empty())
     path_to_name_map_.insert(std::make_pair(path, mount_name));
   return true;
 }
 
+bool ExternalMountPoints::HandlesFileSystemMountType(
+    FileSystemType type) const {
+  return type == kFileSystemTypeExternal;
+}
+
 bool ExternalMountPoints::RevokeFileSystem(const std::string& mount_name) {
   base::AutoLock locker(lock_);
   NameToInstance::iterator found = instance_map_.find(mount_name);
   if (found == instance_map_.end())
     return false;
   Instance* instance = found->second;
   path_to_name_map_.erase(NormalizeFilePath(instance->path()));
   delete found->second;
   instance_map_.erase(found);
   return true;
@@ skipping 47 matching lines @@
       *type = instance->type();
     cracked_path = instance->path();
   }
 
   for (; component_iter != components.end(); ++component_iter)
     cracked_path = cracked_path.Append(*component_iter);
   *path = cracked_path;
   return true;
 }
 
+FileSystemURL ExternalMountPoints::CrackURL(const GURL& url) const {
+  FileSystemURL filesystem_url = FileSystemURL(url);
+  if (!filesystem_url.is_valid())
+    return FileSystemURL();
+  return CreateCrackedFileSystemURL(filesystem_url.origin(),
+                                    filesystem_url.mount_type(),
+                                    filesystem_url.path());
+}
+
+FileSystemURL ExternalMountPoints::CreateCrackedFileSystemURL(
+    const GURL& origin,
+    FileSystemType type,
+    const FilePath& path) const {
+  if (!HandlesFileSystemMountType(type))
+    return FileSystemURL();
+
+  std::string mount_name;
+  FileSystemType cracked_type;
+  FilePath cracked_path;
+  if (!CrackVirtualPath(path, &mount_name, &cracked_type, &cracked_path))
+    return FileSystemURL();
+
+  return FileSystemURL(origin, type, path,
+                       mount_name, cracked_type, cracked_path);
+}
+
 RemoteFileSystemProxyInterface* ExternalMountPoints::GetRemoteFileSystemProxy(
     const std::string& mount_name) const {
   base::AutoLock locker(lock_);
   NameToInstance::const_iterator found = instance_map_.find(mount_name);
   if (found == instance_map_.end())
     return NULL;
   return found->second->remote_proxy();
 }
 
 void ExternalMountPoints::AddMountPointInfosTo(
@@ skipping 88 matching lines @@
   return ExternalMountPoints::GetSystemInstance()->
       CreateVirtualRootPath(mount_name_);
 }
 
 ScopedExternalFileSystem::~ScopedExternalFileSystem() {
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(mount_name_);
 }
 
 }  // namespace fileapi