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 10 matching lines @@
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_mount_point_provider.h"
 #include "webkit/fileapi/mount_points.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/local_file_sync_context.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 #include "webkit/fileapi/test_mount_point_provider.h"
 #include "webkit/quota/quota_manager.h"
-#include "webkit/quota/special_storage_policy.h"
-
-#if defined(OS_CHROMEOS)
-#include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
-#endif
 
 using quota::QuotaClient;
 
 namespace fileapi {
 
 namespace {
 
 QuotaClient* CreateQuotaClient(
     FileSystemContext* context,
     bool is_incognito) {
   return new FileSystemQuotaClient(context, is_incognito);
 }
 
 void DidOpenFileSystem(
     const FileSystemContext::OpenFileSystemCallback& callback,
     const GURL& filesystem_root,
     const std::string& filesystem_name,
     base::PlatformFileError error) {
   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 std::vector<MountPoints*>& additional_mount_points,
     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)),
-      external_mount_points_(external_mount_points),
+      additional_providers_(additional_providers.Pass()),
       partition_path_(partition_path) {
   DCHECK(task_runners_.get());
 
+  RegisterMountPointProvider(sandbox_provider_.get());
+  RegisterMountPointProvider(isolated_provider_.get());
+
+  for (ScopedVector<FileSystemMountPointProvider>::const_iterator iter =
+          additional_providers_.begin();
+       iter != additional_providers_.end(); ++iter) {
+    RegisterMountPointProvider(*iter);
+  }
+
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(CreateQuotaClient(
             this, options.is_incognito()));
   }
 
-#if defined(OS_CHROMEOS)
-  DCHECK(external_mount_points);
-  external_provider_.reset(
-      new chromeos::CrosMountPointProvider(
-          special_storage_policy,
-          external_mount_points,
-          ExternalMountPoints::GetSystemInstance()));
-#endif
-
-  if (external_mount_points)
-    url_crackers_.push_back(external_mount_points);
-  url_crackers_.push_back(ExternalMountPoints::GetSystemInstance());
-  url_crackers_.push_back(IsolatedContext::GetInstance());
+  // Additional mount points must be added before regular system-wide
+  // mount points.
+  for (std::vector<fileapi::MountPoints*>::const_iterator iter =
+           additional_mount_points.begin();
+       iter != additional_mount_points.end(); ++iter) {
+    url_crackers_.push_back(*iter);
+  }
+  url_crackers_.push_back(fileapi::ExternalMountPoints::GetSystemInstance());
+  url_crackers_.push_back(fileapi::IsolatedContext::GetInstance());
 }
 
 bool FileSystemContext::DeleteDataForOriginOnFileThread(
     const GURL& origin_url) {
   DCHECK(task_runners_->file_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(sandbox_provider());
   DCHECK(origin_url == origin_url.GetOrigin());
 
   // Delete temporary and persistent data.
   return
@@ skipping 37 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;
-  }
+  if (provider_map_.find(type) != provider_map_.end())
+    return provider_map_.find(type)->second;

[tzik, 2013/04/17 12:06:04]

could you reuse the result of find(type)?

[kinuko, 2013/04/17 14:27:29]

Done.

+  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*
 FileSystemContext::sandbox_provider() const {
   return sandbox_provider_.get();
 }
 
 ExternalFileSystemMountPointProvider*
 FileSystemContext::external_provider() const {
-  return external_provider_.get();
+  ExternalFileSystemMountPointProvider* external_provider =
+      static_cast<ExternalFileSystemMountPointProvider*>(
+          GetMountPointProvider(kFileSystemTypeExternal));
+  DCHECK(external_provider);
+  return external_provider;
 }
 
 void FileSystemContext::OpenFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     bool create,
     const OpenFileSystemCallback& callback) {
   DCHECK(!callback.is_null());
 
   FileSystemMountPointProvider* mount_point_provider =
@@ skipping 93 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(
+void FileSystemContext::RegisterMountPointProviderForTesting(
     FileSystemType type,
     FileSystemMountPointProvider* provider) {
   DCHECK(provider);
   DCHECK(provider_map_.find(type) == provider_map_.end());
   provider_map_[type] = provider;
+  additional_providers_.push_back(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());
@@ skipping 21 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) {
+  static const FileSystemType mount_types[] = {

[tzik, 2013/04/17 12:06:04]

could you move this to the top of the file?

[kinuko, 2013/04/17 14:27:29]

It's only referred in this method-- I just dropped 'static' here.

+    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]))
+      provider_map_.insert(std::make_pair(mount_types[j], provider));

[tzik, 2013/04/17 12:06:04]

could you add DCHECK the .second of the result?

[kinuko, 2013/04/17 14:27:29]

Done.

+  }
+  // Register mount point providers for internal types.
+  for (int t = kFileSystemInternalTypeEnumStart;

[tzik, 2013/04/17 12:06:04]

kFileSystemInternalTypeEnumStart + 1?

[kinuko, 2013/04/17 14:27:29]

Done.

+        t < kFileSystemInternalTypeEnumEnd; ++t) {

[tzik, 2013/04/17 12:06:04]

indent?

[kinuko, 2013/04/17 14:27:29]

Done.

+    FileSystemType type = static_cast<FileSystemType>(t);
+    if (provider->CanHandleType(type))
+      provider_map_.insert(std::make_pair(type, provider));
+  }
+}
+
 }  // namespace fileapi