Add FileSystemID parameter to IsolatedContext::RegisterFileSystemForPath.

chrome/browser/chromeos/fileapi/file_system_backend.cc

 // Copyright 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 "chrome/browser/chromeos/fileapi/file_system_backend.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/fileapi/file_access_permissions.h"
@@ skipping 78 matching lines @@
 }
 
 void FileSystemBackend::Initialize(fileapi::FileSystemContext* context) {
 }
 
 void FileSystemBackend::ResolveURL(const fileapi::FileSystemURL& url,
                                    fileapi::OpenFileSystemMode mode,
                                    const OpenFileSystemCallback& callback) {
   std::string id;
   fileapi::FileSystemType type;
+  std::string cracked_id;
   base::FilePath path;
   fileapi::FileSystemMountOption option;
   if (!mount_points_->CrackVirtualPath(
-           url.virtual_path(), &id, &type, &path, &option) &&
+           url.virtual_path(), &id, &type, &cracked_id, &path, &option) &&
       !system_mount_points_->CrackVirtualPath(
-           url.virtual_path(), &id, &type, &path, &option)) {
+           url.virtual_path(), &id, &type, &cracked_id, &path, &option)) {
     // Not under a mount point, so return an error, since the root is not
     // accessible.
     GURL root_url = GURL(fileapi::GetExternalFileSystemRootURIString(
         url.origin(), std::string()));
     callback.Run(root_url, std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   std::string name;
   // Construct a URL restricted to the found mount point.
@@ skipping 66 matching lines @@
 
 void FileSystemBackend::GrantFileAccessToExtension(
     const std::string& extension_id, const base::FilePath& virtual_path) {
   // All we care about here is access from extensions for now.
   DCHECK(special_storage_policy_->IsFileHandler(extension_id));
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return;
 
   std::string id;
   fileapi::FileSystemType type;
+  std::string cracked_id;
   base::FilePath path;
   fileapi::FileSystemMountOption option;
-  if (!mount_points_->CrackVirtualPath(virtual_path,
-                                       &id, &type, &path, &option) &&
-      !system_mount_points_->CrackVirtualPath(virtual_path,
-                                              &id, &type, &path, &option)) {
+  if (!mount_points_->CrackVirtualPath(virtual_path, &id, &type, &cracked_id,
+                                       &path, &option) &&
+      !system_mount_points_->CrackVirtualPath(virtual_path, &id, &type,
+                                              &cracked_id, &path, &option)) {
     return;
   }
 
   if (type == fileapi::kFileSystemTypeRestrictedNativeLocal) {
     LOG(ERROR) << "Can't grant access for restricted mount point";
     return;
   }
 
   file_access_permissions_->GrantAccessPermission(extension_id, virtual_path);
 }
@@ skipping 64 matching lines @@
          url.type() == fileapi::kFileSystemTypeDrive ||
          url.type() == fileapi::kFileSystemTypeProvided);
   return fileapi::FileSystemOperation::Create(
       url, context,
       make_scoped_ptr(new fileapi::FileSystemOperationContext(context)));
 }
 
 bool FileSystemBackend::SupportsStreaming(
     const fileapi::FileSystemURL& url) const {
   return url.type() == fileapi::kFileSystemTypeDrive ||
-         url.type() == fileapi::kFileSystemTypeProvided;
+         url.type() == fileapi::kFileSystemTypeProvided ||
+         url.type() == fileapi::kFileSystemTypeDeviceMediaAsFileStorage;
 }
 
 scoped_ptr<webkit_blob::FileStreamReader>
 FileSystemBackend::CreateFileStreamReader(
     const fileapi::FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     fileapi::FileSystemContext* context) const {
   DCHECK(url.is_valid());
 
@@ skipping 54 matching lines @@
 }
 
 bool FileSystemBackend::GetVirtualPath(
     const base::FilePath& filesystem_path,
     base::FilePath* virtual_path) {
   return mount_points_->GetVirtualPath(filesystem_path, virtual_path) ||
          system_mount_points_->GetVirtualPath(filesystem_path, virtual_path);
 }
 
 }  // namespace chromeos