Make MountPointProvider pluggable from outside webkit/fileapi

webkit/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_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/platform_file.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/task_runner_bound_observer_list.h"
 #include "webkit/storage/webkit_storage_export.h"
 
 namespace base {
 class FilePath;
 }
@@ skipping 45 matching lines @@
   // The code assumes that
   // task_runners->file_task_runner()->RunsTasksOnCurrentThread()
   // returns false if the current task is not running on the thread that allows
   // blocking file operations (like SequencedWorkerPool implementation does).
   //
   // |external_mount_points| contains non-system external mount points available
   // in the context. If not NULL, it will be used during URL cracking. On
   // ChromeOS, it will be passed to external_mount_point_provider.
   // |external_mount_points| may be NULL only on platforms different from
   // ChromeOS (i.e. platforms that don't use external_mount_point_provider).
+  //
+  // |additional_providers| are added to the internal provider 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.
   FileSystemContext(
       scoped_ptr<FileSystemTaskRunners> task_runners,
       ExternalMountPoints* external_mount_points,
       quota::SpecialStoragePolicy* special_storage_policy,
       quota::QuotaManagerProxy* quota_manager_proxy,
+      ScopedVector<FileSystemMountPointProvider> additional_providers,
       const base::FilePath& partition_path,
       const FileSystemOptions& options);
 
   bool DeleteDataForOriginOnFileThread(const GURL& origin_url);
 
   quota::QuotaManagerProxy* quota_manager_proxy() const {
     return quota_manager_proxy_.get();
   }
 
   // Returns a quota util for a given filesystem type.  This may
@@ skipping 90 matching lines @@
       const FileSystemURL& url,
       int64 offset,
       const base::Time& expected_modification_time);
 
   // Creates new FileStreamWriter instance to write into a file pointed by
   // |url| from |offset|.
   scoped_ptr<FileStreamWriter> CreateFileStreamWriter(
       const FileSystemURL& url,
       int64 offset);
 
-  // Register a filesystem provider. The ownership of |provider| is
-  // transferred to this instance.
-  void RegisterMountPointProvider(FileSystemType type,
-                                  FileSystemMountPointProvider* provider);
-
   FileSystemTaskRunners* task_runners() { return task_runners_.get(); }
 
   sync_file_system::LocalFileChangeTracker* change_tracker() {
     return change_tracker_.get();
   }
   void SetLocalFileChangeTracker(
       scoped_ptr<sync_file_system::LocalFileChangeTracker> tracker);
 
   sync_file_system::LocalFileSyncContext* sync_context() {
     return sync_context_.get();
   }
   void set_sync_context(sync_file_system::LocalFileSyncContext* sync_context);
 
   const base::FilePath& partition_path() const { return partition_path_; }
 
   // Same as |CrackFileSystemURL|, but cracks FileSystemURL created from |url|.
   FileSystemURL CrackURL(const GURL& url) const;
   // Same as |CrackFileSystemURL|, but cracks FileSystemURL created from method
   // arguments.
   FileSystemURL CreateCrackedFileSystemURL(const GURL& origin,
                                            FileSystemType type,
                                            const base::FilePath& path) const;
 
  private:
+  typedef std::map<FileSystemType, FileSystemMountPointProvider*>
+      MountPointProviderMap;
+
   // Friended for GetFileUtil.
   // These classes know the target filesystem (i.e. sandbox filesystem)
   // supports synchronous FileUtil.
   friend class LocalFileSystemOperation;
   friend class sync_file_system::LocalFileChangeTracker;
   friend class sync_file_system::LocalFileSyncContext;
 
   // Friended for GetFileUtil.
   // Test classes that rely on synchronous FileUtils.
   friend class webkit_blob::BlobURLRequestJobTest;
@@ skipping 19 matching lines @@
   //
   // If the original url does not point to an isolated or external filesystem,
   // returns the original url, without attempting to crack it.
   FileSystemURL CrackFileSystemURL(const FileSystemURL& url) const;
 
   // Returns the appropriate FileUtil instance for the given |type|.
   // This may return NULL if it is given an invalid type or the filesystem
   // does not support synchronous file operations.
   FileSystemFileUtil* GetFileUtil(FileSystemType type) const;
 
+  // For initial provider_map construction. This must be called only from
+  // the constructor.
+  void RegisterMountPointProvider(FileSystemMountPointProvider* provider);
+
   scoped_ptr<FileSystemTaskRunners> task_runners_;
 
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
 
   // Regular mount point providers.
   scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
   scoped_ptr<IsolatedMountPointProvider> isolated_provider_;
   scoped_ptr<ExternalFileSystemMountPointProvider> external_provider_;
 
+  // Additional mount point providers.
+  ScopedVector<FileSystemMountPointProvider> additional_providers_;
+
   // Registered mount point providers.
-  std::map<FileSystemType, FileSystemMountPointProvider*> provider_map_;
-
+  // The map must be constructed in the constructor since it can be accessed
+  // on multiple threads.
+  // The ownership of each provider is held by mount_point_providers_.
+  MountPointProviderMap provider_map_;
   // External mount points visible in the file system context (excluding system
   // external mount points).
   scoped_refptr<ExternalMountPoints> external_mount_points_;
 
   // MountPoints used to crack FileSystemURLs. The MountPoints are ordered
   // in order they should try to crack a FileSystemURL.
   std::vector<MountPoints*> url_crackers_;
 
   // The base path of the storage partition for this context.
   const base::FilePath partition_path_;
 
   // For syncable file systems.
   scoped_ptr<sync_file_system::LocalFileChangeTracker> change_tracker_;
   scoped_refptr<sync_file_system::LocalFileSyncContext> sync_context_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileSystemContext);
 };
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_