fileapi: Rename FileSystemMountProvider to FileSystemBackend

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 30 matching lines @@
 
 namespace webkit_blob {
 class BlobURLRequestJobTest;
 class FileStreamReader;
 }
 
 namespace fileapi {
 
 class AsyncFileUtil;
 class CopyOrMoveFileValidatorFactory;
-class ExternalFileSystemMountPointProvider;
+class ExternalFileSystemBackend;
 class ExternalMountPoints;
 class FileStreamWriter;
 class FileSystemFileUtil;
-class FileSystemMountPointProvider;
+class FileSystemBackend;
 class FileSystemOperation;
 class FileSystemOperationRunner;
 class FileSystemOptions;
 class FileSystemQuotaUtil;
 class FileSystemTaskRunners;
 class FileSystemURL;
 class IsolatedMountPointProvider;
 class MountPoints;
 class SandboxMountPointProvider;
 
@@ skipping 29 matching lines @@
   //
   // |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,
+      ScopedVector<FileSystemBackend> 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 11 matching lines @@
 
   // Returns the appropriate CopyOrMoveFileValidatorFactory for the given
   // |type|.  If |error_code| is PLATFORM_FILE_OK and the result is NULL,
   // then no validator is required.
   CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
       FileSystemType type, base::PlatformFileError* error_code) const;
 
   // Returns the mount point provider instance for the given |type|.
   // This may return NULL if it is given an invalid or unsupported filesystem
   // type.
-  FileSystemMountPointProvider* GetMountPointProvider(
+  FileSystemBackend* GetMountPointProvider(
       FileSystemType type) const;
 
   // Returns true for sandboxed filesystems. Currently this does
   // the same as GetQuotaUtil(type) != NULL. (In an assumption that
   // all sandboxed filesystems must cooperate with QuotaManager so that
   // they can get deleted)
   bool IsSandboxFileSystem(FileSystemType type) const;
 
   // Returns observers for the given filesystem type.
   const UpdateObserverList* GetUpdateObservers(FileSystemType type) const;
   const AccessObserverList* GetAccessObservers(FileSystemType type) const;
 
   // Returns all registered filesystem types.
   void GetFileSystemTypes(std::vector<FileSystemType>* types) const;
 
-  // Returns a FileSystemMountPointProvider instance for external filesystem
+  // Returns a FileSystemBackend instance for external filesystem
   // type, which is used only by chromeos for now.  This is equivalent to
   // calling GetMountPointProvider(kFileSystemTypeExternal).
-  ExternalFileSystemMountPointProvider* external_provider() const;
+  ExternalFileSystemBackend* external_provider() const;
 
   // Used for OpenFileSystem.
   typedef base::Callback<void(base::PlatformFileError result,
                               const std::string& name,
                               const GURL& root)> OpenFileSystemCallback;
 
   // Used for DeleteFileSystem.
   typedef base::Callback<void(base::PlatformFileError result)>
       DeleteFileSystemCallback;
 
@@ skipping 62 matching lines @@
   FileSystemURL CreateCrackedFileSystemURL(const GURL& origin,
                                            FileSystemType type,
                                            const base::FilePath& path) const;
 
 #if defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
   // Used only on ChromeOS for now.
   void EnableTemporaryFileSystemInIncognito();
 #endif
 
  private:
-  typedef std::map<FileSystemType, FileSystemMountPointProvider*>
+  typedef std::map<FileSystemType, FileSystemBackend*>
       MountPointProviderMap;
 
   // For CreateFileSystemOperation.
   friend class FileSystemOperationRunner;
 
   // For sandbox_provider().
   friend class SandboxFileSystemTestHelper;
 
   // Deleters.
   friend struct DefaultContextDeleter;
@@ skipping 19 matching lines @@
   // created by cracking |url|. The url is cracked using MountPoints registered
   // as |url_crackers_|. If the url cannot be cracked, returns invalid
   // FileSystemURL.
   //
   // 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;
 
   // For initial provider_map construction. This must be called only from
   // the constructor.
-  void RegisterMountPointProvider(FileSystemMountPointProvider* provider);
+  void RegisterMountPointProvider(FileSystemBackend* provider);
 
-  // Returns a FileSystemMountPointProvider, used only by test code.
+  // Returns a FileSystemBackend, used only by test code.
   SandboxMountPointProvider* sandbox_provider() const {
     return sandbox_provider_.get();
   }
 
   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_;
 
   // Additional mount point providers.
-  ScopedVector<FileSystemMountPointProvider> additional_providers_;
+  ScopedVector<FileSystemBackend> additional_providers_;
 
   // Registered mount point providers.
   // The map must be constructed in the constructor since it can be accessed
   // on multiple threads.
   // This map itself doesn't retain each provider's ownership; ownerships
   // of the providers are held by additional_providers_ or other scoped_ptr
   // provider fields.
   MountPointProviderMap provider_map_;
 
   // External mount points visible in the file system context (excluding system
@@ skipping 18 matching lines @@
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_