Add FileSystemID parameter to IsolatedContext::RegisterFileSystemForPath.

webkit/browser/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/browser/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 131 matching lines @@
   if (found == instance_map_.end())
     return false;
   *path = found->second->path();
   return true;
 }
 
 bool ExternalMountPoints::CrackVirtualPath(
     const base::FilePath& virtual_path,
     std::string* mount_name,
     FileSystemType* type,
+    std::string* cracked_id,
     base::FilePath* path,
     FileSystemMountOption* mount_option) const {
   DCHECK(mount_name);
   DCHECK(path);
 
   // The path should not contain any '..' references.
   if (virtual_path.ReferencesParent())
     return false;
 
   // The virtual_path should comprise of <mount_name> and <relative_path> parts.
@@ skipping 125 matching lines @@
     // 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(), url.mount_option());
 #endif
   }
 
   std::string mount_name;
   FileSystemType cracked_type;
+  std::string cracked_id;
   base::FilePath cracked_path;
   FileSystemMountOption cracked_mount_option;
 
   if (!CrackVirtualPath(virtual_path, &mount_name, &cracked_type,
-                        &cracked_path, &cracked_mount_option)) {
+                        &cracked_id, &cracked_path, &cracked_mount_option)) {
     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, cracked_mount_option);
+      cracked_type, cracked_path,
+      cracked_id.empty() ? mount_name : cracked_id, cracked_mount_option);
 }
 
 bool ExternalMountPoints::ValidateNewMountPoint(const std::string& mount_name,
                                                 FileSystemType type,
                                                 const base::FilePath& path) {
   lock_.AssertAcquired();
 
   // Mount name must not be empty.
   if (mount_name.empty())
     return false;
@@ skipping 29 matching lines @@
           path.IsParent(potential_child->first)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 }  // namespace fileapi