Make MountPointProvider pluggable from outside webkit/fileapi

webkit/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/fileapi/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/single_thread_task_runner.h"
 #include "googleurl/src/gurl.h"
@@ skipping 43 matching lines @@
   callback.Run(error, filesystem_name, filesystem_root);
 }
 
 }  // namespace
 
 FileSystemContext::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)
     : task_runners_(task_runners.Pass()),
       quota_manager_proxy_(quota_manager_proxy),
       sandbox_provider_(
           new SandboxMountPointProvider(
               quota_manager_proxy,
               task_runners_->file_task_runner(),
               partition_path,
               options)),
       isolated_provider_(new IsolatedMountPointProvider(partition_path)),
+      additional_providers_(additional_providers.Pass()),
       external_mount_points_(external_mount_points),
       partition_path_(partition_path) {
   DCHECK(task_runners_.get());
 
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(CreateQuotaClient(
             this, options.is_incognito()));
   }
 
+  RegisterMountPointProvider(sandbox_provider_.get());
+  RegisterMountPointProvider(isolated_provider_.get());
+
 #if defined(OS_CHROMEOS)
+  // TODO(kinuko): Move this out of webkit/fileapi layer.
   DCHECK(external_mount_points);
   external_provider_.reset(
       new chromeos::CrosMountPointProvider(
           special_storage_policy,
           external_mount_points,
           ExternalMountPoints::GetSystemInstance()));
+  RegisterMountPointProvider(external_provider_.get());
 #endif
 
+  for (ScopedVector<FileSystemMountPointProvider>::const_iterator iter =
+          additional_providers_.begin();
+       iter != additional_providers_.end(); ++iter) {
+    RegisterMountPointProvider(*iter);
+  }
+
+  // Additional mount points must be added before regular system-wide
+  // mount points.
   if (external_mount_points)
     url_crackers_.push_back(external_mount_points);
   url_crackers_.push_back(ExternalMountPoints::GetSystemInstance());
   url_crackers_.push_back(IsolatedContext::GetInstance());
 }
 
 bool FileSystemContext::DeleteDataForOriginOnFileThread(
     const GURL& origin_url) {
   DCHECK(task_runners_->file_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(sandbox_provider());
@@ skipping 41 matching lines @@
   FileSystemMountPointProvider* mount_point_provider =
       GetMountPointProvider(type);
   if (!mount_point_provider)
     return NULL;
   return mount_point_provider->GetCopyOrMoveFileValidatorFactory(
       type, error_code);
 }
 
 FileSystemMountPointProvider* FileSystemContext::GetMountPointProvider(
     FileSystemType type) const {
-  switch (type) {
-    case kFileSystemTypeTemporary:
-    case kFileSystemTypePersistent:
-    case kFileSystemTypeSyncable:
-      return sandbox_provider_.get();
-    case kFileSystemTypeExternal:
-    case kFileSystemTypeDrive:
-    case kFileSystemTypeRestrictedNativeLocal:
-      return external_provider_.get();
-    case kFileSystemTypeIsolated:
-    case kFileSystemTypeDragged:
-    case kFileSystemTypeNativeMedia:
-    case kFileSystemTypeDeviceMedia:
-      return isolated_provider_.get();
-    case kFileSystemTypeNativeLocal:
-    case kFileSystemTypeNativeForPlatformApp:
-#if defined(OS_CHROMEOS)
-      return external_provider_.get();
-#else
-      return isolated_provider_.get();
-#endif
-    default:
-      if (provider_map_.find(type) != provider_map_.end())
-        return provider_map_.find(type)->second;
-      // Fall through.
-    case kFileSystemTypeUnknown:
-      NOTREACHED();
-      return NULL;
-  }
+  MountPointProviderMap::const_iterator found = provider_map_.find(type);
+  if (found != provider_map_.end())
+    return found->second;
+  NOTREACHED() << "Unknown filesystem type: " << type;
+  return NULL;
 }
 
 const UpdateObserverList* FileSystemContext::GetUpdateObservers(
     FileSystemType type) const {
   // Currently update observer is only available in SandboxMountPointProvider
   // and TestMountPointProvider.
   // TODO(kinuko): Probably GetUpdateObservers() virtual method should be
   // added to FileSystemMountPointProvider interface and be called like
   // other GetFoo() methods do.
-  if (SandboxMountPointProvider::CanHandleType(type))
+  if (SandboxMountPointProvider::IsSandboxType(type))
     return sandbox_provider()->GetUpdateObservers(type);
   if (type != kFileSystemTypeTest)
     return NULL;
   FileSystemMountPointProvider* mount_point_provider =
       GetMountPointProvider(type);
   return static_cast<TestMountPointProvider*>(
       mount_point_provider)->GetUpdateObservers(type);
 }
 
 SandboxMountPointProvider*
@@ skipping 110 matching lines @@
     int64 offset) {
   if (!url.is_valid())
     return scoped_ptr<FileStreamWriter>();
   FileSystemMountPointProvider* mount_point_provider =
       GetMountPointProvider(url.type());
   if (!mount_point_provider)
     return scoped_ptr<FileStreamWriter>();
   return mount_point_provider->CreateFileStreamWriter(url, offset, this);
 }
 
-void FileSystemContext::RegisterMountPointProvider(
-    FileSystemType type,
-    FileSystemMountPointProvider* provider) {
-  DCHECK(provider);
-  DCHECK(provider_map_.find(type) == provider_map_.end());
-  provider_map_[type] = provider;
-}
-
 void FileSystemContext::SetLocalFileChangeTracker(
     scoped_ptr<sync_file_system::LocalFileChangeTracker> tracker) {
   DCHECK(!change_tracker_.get());
   DCHECK(tracker.get());
   change_tracker_ = tracker.Pass();
   sandbox_provider_->AddSyncableFileUpdateObserver(
       change_tracker_.get(),
       task_runners_->file_task_runner());
   sandbox_provider_->AddSyncableFileChangeObserver(
       change_tracker_.get(),
@@ skipping 19 matching lines @@
 FileSystemContext::~FileSystemContext() {
   task_runners_->file_task_runner()->DeleteSoon(
       FROM_HERE, change_tracker_.release());
 }
 
 void FileSystemContext::DeleteOnCorrectThread() const {
   if (!task_runners_->io_task_runner()->RunsTasksOnCurrentThread() &&
       task_runners_->io_task_runner()->DeleteSoon(FROM_HERE, this)) {
     return;
   }
-  STLDeleteContainerPairSecondPointers(provider_map_.begin(),
-                                       provider_map_.end());
   delete this;
 }
 
 FileSystemURL FileSystemContext::CrackFileSystemURL(
     const FileSystemURL& url) const {
   if (!url.is_valid())
     return FileSystemURL();
 
   // The returned value in case there is no crackers which can crack the url.
   // This is valid situation for non isolated/external file systems.
@@ skipping 19 matching lines @@
 
 FileSystemFileUtil* FileSystemContext::GetFileUtil(
     FileSystemType type) const {
   FileSystemMountPointProvider* mount_point_provider =
       GetMountPointProvider(type);
   if (!mount_point_provider)
     return NULL;
   return mount_point_provider->GetFileUtil(type);
 }
 
+void FileSystemContext::RegisterMountPointProvider(
+    FileSystemMountPointProvider* provider) {
+  const FileSystemType mount_types[] = {
+    kFileSystemTypeTemporary,
+    kFileSystemTypePersistent,
+    kFileSystemTypeIsolated,
+    kFileSystemTypeExternal,
+  };
+  // Register mount point providers for public mount types.
+  for (size_t j = 0; j < ARRAYSIZE_UNSAFE(mount_types); ++j) {
+    if (provider->CanHandleType(mount_types[j])) {
+      const bool inserted = provider_map_.insert(
+          std::make_pair(mount_types[j], provider)).second;
+      DCHECK(inserted);
+    }
+  }
+  // Register mount point providers for internal types.
+  for (int t = kFileSystemInternalTypeEnumStart + 1;
+       t < kFileSystemInternalTypeEnumEnd; ++t) {
+    FileSystemType type = static_cast<FileSystemType>(t);
+    if (provider->CanHandleType(type)) {
+      const bool inserted = provider_map_.insert(
+          std::make_pair(type, provider)).second;
+      DCHECK(inserted);
+    }
+  }
+}
+
 }  // namespace fileapi