Launch packaged app with files on Drive on Chrome OS.

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/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
@@ skipping 111 matching lines @@
     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;
+  return type == kFileSystemTypeExternal ||
+         type == kFileSystemTypeNativeForPlatformApp;
 }
 
 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;
@@ skipping 53 matching lines @@
   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());
+  return CrackFileSystemURL(filesystem_url);
 }
 
 FileSystemURL ExternalMountPoints::CreateCrackedFileSystemURL(
     const GURL& origin,
     FileSystemType type,
     const base::FilePath& path) const {
-  if (!HandlesFileSystemMountType(type))
-    return FileSystemURL();
-
-  std::string mount_name;
-  FileSystemType cracked_type;
-  base::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);
+  return CrackFileSystemURL(FileSystemURL(origin, type, 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(
     std::vector<MountPointInfo>* mount_points) const {
   base::AutoLock locker(lock_);
   DCHECK(mount_points);
   for (NameToInstance::const_iterator iter = instance_map_.begin();
        iter != instance_map_.end(); ++iter) {
     mount_points->push_back(MountPointInfo(iter->first, iter->second->path()));
   }
 }
 
 bool ExternalMountPoints::GetVirtualPath(const base::FilePath& path_in,
-                                         base::FilePath* virtual_path) {
+                                         base::FilePath* virtual_path) const {
   DCHECK(virtual_path);
 
   base::AutoLock locker(lock_);
 
   base::FilePath path = NormalizeFilePath(path_in);
-  std::map<base::FilePath, std::string>::reverse_iterator iter(
+  std::map<base::FilePath, std::string>::const_reverse_iterator iter(
       path_to_name_map_.upper_bound(path));
   if (iter == path_to_name_map_.rend())
     return false;
 
   *virtual_path = CreateVirtualRootPath(iter->second);
   if (iter->first == path)
     return true;
   return iter->first.AppendRelativePath(path, virtual_path);
 }
 
 base::FilePath ExternalMountPoints::CreateVirtualRootPath(
     const std::string& mount_name) const {
   return base::FilePath().AppendASCII(mount_name);
 }
 
 ExternalMountPoints::ExternalMountPoints() {}
 
 ExternalMountPoints::~ExternalMountPoints() {
   STLDeleteContainerPairSecondPointers(instance_map_.begin(),
                                        instance_map_.end());
 }
 
+FileSystemURL ExternalMountPoints::CrackFileSystemURL(
+    const FileSystemURL& url) const {
+  if (!HandlesFileSystemMountType(url.type()))
+    return FileSystemURL();
+
+  base::FilePath virtual_path = url.path();
+  if (url.type() == kFileSystemTypeNativeForPlatformApp) {
+#if defined(OS_CHROMEOS)
+    // On Chrome OS, find a mount point and virtual path for the external fs.
+    if (!GetVirtualPath(url.path(), &virtual_path))
+      return FileSystemURL();
+#else
+    // On other OS, it is simply a native local path.
+    return FileSystemURL(
+        url.origin(), url.mount_type(), url.virtual_path(),
+        url.mount_filesystem_id(), kFileSystemTypeNativeLocal,
+        url.path(), url.filesystem_id());
+#endif
+  }
+
+  std::string mount_name;
+  FileSystemType cracked_type;
+  base::FilePath cracked_path;
+
+  if (!CrackVirtualPath(virtual_path, &mount_name, &cracked_type,
+                        &cracked_path)) {
+    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);
+}
+
 bool ExternalMountPoints::ValidateNewMountPoint(const std::string& mount_name,
                                                 const base::FilePath& path) {
   lock_.AssertAcquired();
 
   // Mount name must not be empty.
   if (mount_name.empty())
     return false;
 
   // Verify there is no registered mount point with the same name.
   NameToInstance::iterator found = instance_map_.find(mount_name);
@@ skipping 38 matching lines @@
 base::FilePath ScopedExternalFileSystem::GetVirtualRootPath() const {
   return ExternalMountPoints::GetSystemInstance()->
       CreateVirtualRootPath(mount_name_);
 }
 
 ScopedExternalFileSystem::~ScopedExternalFileSystem() {
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(mount_name_);
 }
 
 }  // namespace fileapi