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

webkit/browser/fileapi/file_system_context.h

 // 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.
 
 #ifndef WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 20 matching lines @@
 
 namespace chrome {
 class NativeMediaFileUtilTest;
 }
 
 namespace quota {
 class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
+namespace net {
+class URLRequest;
+}
+
 namespace webkit_blob {
 class BlobURLRequestJobTest;
 class FileStreamReader;
 }
 
 namespace fileapi {
 
 class AsyncFileUtil;
 class CopyOrMoveFileValidatorFactory;
 class ExternalFileSystemBackend;
 class ExternalMountPoints;
 class FileStreamWriter;
 class FileSystemBackend;
 class FileSystemFileUtil;
 class FileSystemOperation;
 class FileSystemOperationRunner;
 class FileSystemOptions;
 class FileSystemQuotaUtil;
 class FileSystemURL;
 class IsolatedFileSystemBackend;
 class MountPoints;
 class QuotaReservation;
 class SandboxFileSystemBackend;
 
 struct DefaultContextDeleter;
 struct FileSystemInfo;
 
+// An auto mount handler will attempt to mount the file system requested in
+// |url_request|. If the URL is for this auto mount handler, it returns true
+// and calls |callback| when the attempt is complete. If the auto mounter
+// does not recognize the URL, it returns false and does not call |callback|.
+typedef base::Callback<bool(
+    const net::URLRequest* url_request,
+    const FileSystemURL& filesystem_url,
+    const std::string& storage_domain,
+    const base::Callback<void(base::File::Error result)>& callback)>
+        URLRequestAutoMountHandler;
+
 // This class keeps and provides a file system context for FileSystem API.
 // An instance of this class is created and owned by profile.
 class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemContext
     : public base::RefCountedThreadSafe<FileSystemContext,
                                         DefaultContextDeleter> {
  public:
   // Returns file permission policy we should apply for the given |type|.
   // The return value must be bitwise-or'd of FilePermissionPolicy.
   //
   // Note: if a part of a filesystem is returned via 'Isolated' mount point,
@@ skipping 10 matching lines @@
   //
   // |external_mount_points| contains non-system external mount points available
   // in the context. If not NULL, it will be used during URL cracking.
   // |external_mount_points| may be NULL only on platforms different from
   // ChromeOS (i.e. platforms that don't use external_mount_point_provider).
   //
   // |additional_backends| are added to the internal backend map
   // to serve filesystem requests for non-regular types.
   // If none is given, this context only handles HTML5 Sandbox FileSystem
   // and Drag-and-drop Isolated FileSystem requests.
+  //
+  // |auto_mount_handlers| are used to resolve calls to
+  // AttemptAutoMountForURLRequest. Only external filesystems can be auto
+  // mounted.
   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,
       const base::FilePath& partition_path,
       const FileSystemOptions& options);
 
   bool DeleteDataForOriginOnFileTaskRunner(const GURL& origin_url);
 
   // Creates a new QuotaReservation for the given |origin_url| and |type|.
   // Returns NULL if |type| does not support quota or reservation fails.
   // This should be run on |default_file_task_runner_| and the returned value
   // should be destroyed on the runner.
   scoped_refptr<QuotaReservation> CreateQuotaReservationOnFileTaskRunner(
@@ skipping 71 matching lines @@
       OpenFileSystemMode mode,
       const OpenFileSystemCallback& callback);
 
   // Opens the filesystem for the given |url| as read-only, and then checks the
   // existence of the file entry referred by the URL. This should be called on
   // the IO thread.
   void ResolveURL(
       const FileSystemURL& url,
       const ResolveURLCallback& callback);
 
+  // Attempts to mount the filesystem needed to satisfy |url_request| made
+  // from |storage_domain|. If an appropriate file system is not found,
+  // callback will return an error.
+  void AttemptAutoMountForURLRequest(const net::URLRequest* url_request,
+                                     const std::string& storage_domain,
+                                     const StatusCallback& callback);
+
   // Deletes the filesystem for the given |origin_url| and |type|. This should
   // be called on the IO thread.
   void DeleteFileSystem(
       const GURL& origin_url,
       FileSystemType type,
       const StatusCallback& callback);
 
   // Creates new FileStreamReader instance to read a file pointed by the given
   // filesystem URL |url| starting from |offset|. |expected_modification_time|
   // specifies the expected last modification if the value is non-null, the
@@ skipping 130 matching lines @@
   scoped_ptr<SandboxFileSystemBackendDelegate> sandbox_delegate_;
 
   // Regular file system backends.
   scoped_ptr<SandboxFileSystemBackend> sandbox_backend_;
   scoped_ptr<IsolatedFileSystemBackend> isolated_backend_;
 
   // Additional file system backends.
   scoped_ptr<PluginPrivateFileSystemBackend> plugin_private_backend_;
   ScopedVector<FileSystemBackend> additional_backends_;
 
+  std::vector<URLRequestAutoMountHandler> auto_mount_handlers_;
+
   // Registered file system backends.
   // The map must be constructed in the constructor since it can be accessed
   // on multiple threads.
   // This map itself doesn't retain each backend's ownership; ownerships
   // of the backends are held by additional_backends_ or other scoped_ptr
   // backend fields.
   FileSystemBackendMap backend_map_;
 
   // External mount points visible in the file system context (excluding system
   // external mount points).
@@ skipping 15 matching lines @@
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_