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 40 matching lines @@
                                         DefaultContextDeleter> {
  public:
   // task_runners->file_task_runner() is used as default TaskRunner.
   // Unless a MountPointProvider is overridden in CreateFileSystemOperation,
   // it is used for all file operations and file related meta operations.
   // 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.
+  //
+  // |additional_mount_points| is used to crack FileSystemURL in
+  // CrackFileSystemURL() (in addition to default system-wide mount points).
   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 std::vector<MountPoints*>& additional_mount_points,
       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 91 matching lines @@
       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);
+  // transferred to this instance. This must be used only for testing.
+  void RegisterMountPointProviderForTesting(
+      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() {
@@ skipping 44 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.
+  // The map must be constructed in the constructor (other than for testing)
+  // since it can be accessed on multiple threads.
+  // The ownership of each provider is held by mount_point_providers_.
   std::map<FileSystemType, FileSystemMountPointProvider*> 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_