Add mechanism to auto mount file systems in response to a URL request.

webkit/browser/fileapi/file_system_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/browser/fileapi/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
+#include "net/url_request/url_request.h"
 #include "url/gurl.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_permission_policy.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_options.h"
@@ skipping 85 matching lines @@
   return FILE_PERMISSION_ALWAYS_DENY;
 }
 
 FileSystemContext::FileSystemContext(
     base::SingleThreadTaskRunner* io_task_runner,
     base::SequencedTaskRunner* file_task_runner,
     ExternalMountPoints* external_mount_points,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     ScopedVector<FileSystemBackend> additional_backends,
+    std::vector<URLRequestAutoMountHandler> auto_mount_handlers,

[kinuko, 2014/03/13 04:19:19]

const ref?

[vandebo (ex-Chrome), 2014/03/13 20:19:32]

Oops.  Fixed.

     const base::FilePath& partition_path,
     const FileSystemOptions& options)
     : io_task_runner_(io_task_runner),
       default_file_task_runner_(file_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
       sandbox_delegate_(new SandboxFileSystemBackendDelegate(
           quota_manager_proxy,
           file_task_runner,
           partition_path,
           special_storage_policy,
           options)),
       sandbox_backend_(new SandboxFileSystemBackend(
           sandbox_delegate_.get())),
       isolated_backend_(new IsolatedFileSystemBackend()),
       plugin_private_backend_(new PluginPrivateFileSystemBackend(
           file_task_runner,
           partition_path,
           special_storage_policy,
           options)),
       additional_backends_(additional_backends.Pass()),
+      auto_mount_handlers_(auto_mount_handlers),
       external_mount_points_(external_mount_points),
       partition_path_(partition_path),
       is_incognito_(options.is_incognito()),
       operation_runner_(new FileSystemOperationRunner(this)) {
   RegisterBackend(sandbox_backend_.get());
   RegisterBackend(isolated_backend_.get());
   RegisterBackend(plugin_private_backend_.get());
 
   for (ScopedVector<FileSystemBackend>::const_iterator iter =
           additional_backends_.begin();
@@ skipping 184 matching lines @@
 
   backend->ResolveURL(
       url,
       OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
       base::Bind(&FileSystemContext::DidOpenFileSystemForResolveURL,
                  this,
                  url,
                  callback));
 }
 
+void FileSystemContext::AttemptAutoMountForURLRequest(

[kinuko, 2014/03/12 05:50:40]

Will you need this only for URL request? Do we also want to do similar for
ResolveURL?

[vandebo (ex-Chrome), 2014/03/12 18:35:54]

I initially tried making this part of ResolveURL or OpenFileSystem, but neither
had the information needed.  Specifically, from the URLRequest you can get back
the RenderViewHost of the requestor.

I'm still not clear where Open and Resolve would be called for a media gallery
file system.

[kinuko, 2014/03/13 04:19:19]

(Assuming you're going to support toURL for media gallery files) ResolveURL will
be called if one tries to get a FileEntry from a filesystem: URL by calling
webkitResolveLocalFileSystemURL.

http://www.w3.org/TR/file-system-api/#widl-LocalFileSystem-resolveLocalFileSy...

If it's not expected usage it's ok to leave it in this patch.

(Btw what's missing in ResolveURL for your case? Will you need url_request info
other than storage_domain?  I'd like to know if it could be a TODO issue we can
fix later, since the 'AutoMount' feature itself looks useful but limiting this
to RequestURL only will narrow the potential future application)

[vandebo (ex-Chrome), 2014/03/13 20:19:32]

Hmm... That's specifically for "Local" filesystem URLs.  I think it's ok to
return an error for media galleries fs URLs.
So the thing in URLRequest that makes it all work is that back up in the content
layer, I can use ResourceRequestInfo to get back to a RenderViewHost and
Profile.  See this WIP CL:
https://codereview.chromium.org/185393012/diff/40001/chrome/browser/media_gal...

The media galleries code ensures that the FS is cleaned up when all the RVH
consumers of it go away.

+    const net::URLRequest* url_request,
+    const std::string& storage_domain,
+    const StatusCallback& callback) {
+  FileSystemURL filesystem_url = FileSystemURL(url_request->url());
+  if (filesystem_url.type() == kFileSystemTypeExternal) {
+    for (size_t i = 0; i < auto_mount_handlers_.size(); i++) {
+      if (auto_mount_handlers_[i].Run(url_request, filesystem_url,
+                                      storage_domain, callback)) {
+        return;
+      }
+    }
+  }
+  callback.Run(base::File::FILE_ERROR_NOT_FOUND);
+}
+
 void FileSystemContext::DeleteFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const StatusCallback& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origin_url == origin_url.GetOrigin());
   DCHECK(!callback.is_null());
 
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
@@ skipping 205 matching lines @@
   } else if (parent != child) {
     bool result = parent.AppendRelativePath(child, &path);
     DCHECK(result);
   }
 
   operation_runner()->GetMetadata(
       url, base::Bind(&DidGetMetadataForResolveURL, path, callback, info));
 }
 
 }  // namespace fileapi