fileapi: Rename FileSystemMountProvider to FileSystemBackend

webkit/browser/fileapi/sandbox_file_system_backend.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/browser/fileapi/sandbox_mount_point_provider.h"
+#include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "net/base/net_util.h"
@@ skipping 52 matching lines @@
 const base::FilePath::CharType* const kRestrictedNames[] = {
   FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
 };
 
 // Restricted chars.
 const base::FilePath::CharType kRestrictedChars[] = {
   FILE_PATH_LITERAL('/'), FILE_PATH_LITERAL('\\'),
 };
 
 class ObfuscatedOriginEnumerator
-    : public SandboxMountPointProvider::OriginEnumerator {
+    : public SandboxFileSystemBackend::OriginEnumerator {
  public:
   explicit ObfuscatedOriginEnumerator(ObfuscatedFileUtil* file_util) {
     enum_.reset(file_util->CreateOriginEnumerator());
   }
   virtual ~ObfuscatedOriginEnumerator() {}
 
   virtual GURL Next() OVERRIDE {
     return enum_->Next();
   }
 
   virtual bool HasFileSystemType(fileapi::FileSystemType type) const OVERRIDE {
     return enum_->HasFileSystemType(type);
   }
 
  private:
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
 void DidOpenFileSystem(
-    base::WeakPtr<SandboxMountPointProvider> mount_point_provider,
-    const FileSystemMountPointProvider::OpenFileSystemCallback& callback,
+    base::WeakPtr<SandboxFileSystemBackend> mount_point_provider,
+    const FileSystemBackend::OpenFileSystemCallback& callback,
     base::PlatformFileError* error) {
   if (mount_point_provider.get())
     mount_point_provider.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
 }
 
 void OpenFileSystemOnFileThread(
     ObfuscatedFileUtil* file_util,
     const GURL& origin_url,
     FileSystemType type,
@@ skipping 13 matching lines @@
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
   }
   // The reference of file_util will be derefed on the FILE thread
   // when the storage of this callback gets deleted regardless of whether
   // this method is called or not.
 }
 
 }  // anonymous namespace
 
 const base::FilePath::CharType
-SandboxMountPointProvider::kFileSystemDirectory[] =
+SandboxFileSystemBackend::kFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
-SandboxMountPointProvider::SandboxMountPointProvider(
+SandboxFileSystemBackend::SandboxFileSystemBackend(
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& profile_path,
     const FileSystemOptions& file_system_options,
     quota::SpecialStoragePolicy* special_storage_policy)
     : file_task_runner_(file_task_runner),
       profile_path_(profile_path),
       file_system_options_(file_system_options),
       enable_temporary_file_system_in_incognito_(false),
       sandbox_file_util_(
@@ skipping 30 matching lines @@
   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
     // Post prepopulate task only if it's not already running on
     // file_task_runner (which implies running in tests).
     file_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase,
                   base::Unretained(sandbox_sync_file_util())));
   }
 }
 
-SandboxMountPointProvider::~SandboxMountPointProvider() {
+SandboxFileSystemBackend::~SandboxFileSystemBackend() {
   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
     AsyncFileUtilAdapter* sandbox_file_util = sandbox_file_util_.release();
     SandboxQuotaObserver* quota_observer = quota_observer_.release();
     FileSystemUsageCache* file_system_usage_cache =
         file_system_usage_cache_.release();
     if (!file_task_runner_->DeleteSoon(FROM_HERE, sandbox_file_util))
       delete sandbox_file_util;
     if (!file_task_runner_->DeleteSoon(FROM_HERE, quota_observer))
       delete quota_observer;
     if (!file_task_runner_->DeleteSoon(FROM_HERE, file_system_usage_cache))
       delete file_system_usage_cache;
   }
 }
 
-bool SandboxMountPointProvider::CanHandleType(FileSystemType type) const {
+bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
   return type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent ||
          type == kFileSystemTypeSyncable ||
          type == kFileSystemTypeSyncableForInternalSync;
 }
 
-void SandboxMountPointProvider::OpenFileSystem(
+void SandboxFileSystemBackend::OpenFileSystem(
     const GURL& origin_url, fileapi::FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
   if (file_system_options_.is_incognito() &&
       !(type == kFileSystemTypeTemporary &&
         enable_temporary_file_system_in_incognito_)) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kIncognito,
@@ skipping 20 matching lines @@
                  weak_factory_.GetWeakPtr(),
                  callback, base::Owned(error_ptr)));
 
   if (enable_usage_tracking_)
     return;
 
   // Schedule full usage recalculation on the next launch without
   // --disable-file-system-usage-tracking.
   file_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SandboxMountPointProvider::InvalidateUsageCacheOnFileThread,
+      base::Bind(&SandboxFileSystemBackend::InvalidateUsageCacheOnFileThread,
                  sandbox_sync_file_util(), origin_url, type,
                  file_system_usage_cache_.get()));
 };
 
-FileSystemFileUtil* SandboxMountPointProvider::GetFileUtil(
+FileSystemFileUtil* SandboxFileSystemBackend::GetFileUtil(
     FileSystemType type) {
   DCHECK(sandbox_file_util_.get());
   return sandbox_file_util_->sync_file_util();
 }
 
-AsyncFileUtil* SandboxMountPointProvider::GetAsyncFileUtil(
+AsyncFileUtil* SandboxFileSystemBackend::GetAsyncFileUtil(
     FileSystemType type) {
   return sandbox_file_util_.get();
 }
 
 CopyOrMoveFileValidatorFactory*
-SandboxMountPointProvider::GetCopyOrMoveFileValidatorFactory(
+SandboxFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
     FileSystemType type,
     base::PlatformFileError* error_code) {
   DCHECK(error_code);
   *error_code = base::PLATFORM_FILE_OK;
   return NULL;
 }
 
-FileSystemOperation* SandboxMountPointProvider::CreateFileSystemOperation(
+FileSystemOperation* SandboxFileSystemBackend::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context,
     base::PlatformFileError* error_code) const {
   if (!IsAccessValid(url)) {
     *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
     return NULL;
   }
 
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
@@ skipping 14 matching lines @@
       special_storage_policy_->IsStorageUnlimited(url.origin())) {
     operation_context->set_quota_limit_type(quota::kQuotaLimitTypeUnlimited);
   } else {
     operation_context->set_quota_limit_type(quota::kQuotaLimitTypeLimited);
   }
 
   return new LocalFileSystemOperation(url, context, operation_context.Pass());
 }
 
 scoped_ptr<webkit_blob::FileStreamReader>
-SandboxMountPointProvider::CreateFileStreamReader(
+SandboxFileSystemBackend::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
   if (!IsAccessValid(url))
     return scoped_ptr<webkit_blob::FileStreamReader>();
   return scoped_ptr<webkit_blob::FileStreamReader>(
       new FileSystemFileStreamReader(
           context, url, offset, expected_modification_time));
 }
 
 scoped_ptr<fileapi::FileStreamWriter>
-SandboxMountPointProvider::CreateFileStreamWriter(
+SandboxFileSystemBackend::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   if (!IsAccessValid(url))
     return scoped_ptr<fileapi::FileStreamWriter>();
   return scoped_ptr<fileapi::FileStreamWriter>(
       new SandboxFileStreamWriter(context, url, offset, update_observers_));
 }
 
-FileSystemQuotaUtil* SandboxMountPointProvider::GetQuotaUtil() {
+FileSystemQuotaUtil* SandboxFileSystemBackend::GetQuotaUtil() {
   return this;
 }
 
-SandboxMountPointProvider::OriginEnumerator*
-SandboxMountPointProvider::CreateOriginEnumerator() {
+SandboxFileSystemBackend::OriginEnumerator*
+SandboxFileSystemBackend::CreateOriginEnumerator() {
   return new ObfuscatedOriginEnumerator(sandbox_sync_file_util());
 }
 
-base::FilePath SandboxMountPointProvider::GetBaseDirectoryForOriginAndType(
+base::FilePath SandboxFileSystemBackend::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) {
 
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath path = sandbox_sync_file_util()->GetDirectoryForOriginAndType(
       origin_url, type, create, &error);
   if (error != base::PLATFORM_FILE_OK)
     return base::FilePath();
   return path;
 }
 
 base::PlatformFileError
-SandboxMountPointProvider::DeleteOriginDataOnFileThread(
+SandboxFileSystemBackend::DeleteOriginDataOnFileThread(
     FileSystemContext* file_system_context,
     QuotaManagerProxy* proxy,
     const GURL& origin_url,
     fileapi::FileSystemType type) {
 
   int64 usage = GetOriginUsageOnFileThread(file_system_context,
                                            origin_url, type);
 
   file_system_usage_cache_->CloseCacheFiles();
   bool result = sandbox_sync_file_util()->DeleteDirectoryForOriginAndType(
           origin_url, type);
   if (result && proxy) {
     proxy->NotifyStorageModified(
         quota::QuotaClient::kFileSystem,
         origin_url,
         FileSystemTypeToQuotaStorageType(type),
         -usage);
   }
 
   if (result)
     return base::PLATFORM_FILE_OK;
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
-void SandboxMountPointProvider::GetOriginsForTypeOnFileThread(
+void SandboxFileSystemBackend::GetOriginsForTypeOnFileThread(
     fileapi::FileSystemType type, std::set<GURL>* origins) {
   DCHECK(CanHandleType(type));
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
   switch (type) {
     case kFileSystemTypeTemporary:
       UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size());
       break;
     case kFileSystemTypePersistent:
       UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size());
       break;
     case kFileSystemTypeSyncable:
       UMA_HISTOGRAM_COUNTS(kSyncableOriginsCountLabel, origins->size());
       break;
     default:
       break;
   }
 }
 
-void SandboxMountPointProvider::GetOriginsForHostOnFileThread(
+void SandboxFileSystemBackend::GetOriginsForHostOnFileThread(
     fileapi::FileSystemType type, const std::string& host,
     std::set<GURL>* origins) {
   DCHECK(CanHandleType(type));
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (host == net::GetHostOrSpecFromURL(origin) &&
         enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
 }
 
-int64 SandboxMountPointProvider::GetOriginUsageOnFileThread(
+int64 SandboxFileSystemBackend::GetOriginUsageOnFileThread(
     FileSystemContext* file_system_context,
     const GURL& origin_url,
     fileapi::FileSystemType type) {
   DCHECK(CanHandleType(type));
   if (!enable_usage_tracking_)
     return 0;
 
   // Don't use usage cache and return recalculated usage for sticky invalidated
   // origins.
   if (ContainsKey(sticky_dirty_origins_, std::make_pair(origin_url, type)))
@@ skipping 22 matching lines @@
   // Get the directory size now and update the cache.
   file_system_usage_cache_->Delete(usage_file_path);
 
   int64 usage = RecalculateUsage(file_system_context, origin_url, type);
 
   // This clears the dirty flag too.
   file_system_usage_cache_->UpdateUsage(usage_file_path, usage);
   return usage;
 }
 
-void SandboxMountPointProvider::InvalidateUsageCache(
+void SandboxFileSystemBackend::InvalidateUsageCache(
     const GURL& origin,
     fileapi::FileSystemType type) {
   DCHECK(CanHandleType(type));
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       sandbox_sync_file_util(), origin, type, &error);
   if (error != base::PLATFORM_FILE_OK)
     return;
   file_system_usage_cache_->IncrementDirty(usage_file_path);
 }
 
-void SandboxMountPointProvider::StickyInvalidateUsageCache(
+void SandboxFileSystemBackend::StickyInvalidateUsageCache(
     const GURL& origin,
     fileapi::FileSystemType type) {
   DCHECK(CanHandleType(type));
   sticky_dirty_origins_.insert(std::make_pair(origin, type));
   quota_observer_->SetUsageCacheEnabled(origin, type, false);
   InvalidateUsageCache(origin, type);
 }
 
-void SandboxMountPointProvider::CollectOpenFileSystemMetrics(
+void SandboxFileSystemBackend::CollectOpenFileSystemMetrics(
     base::PlatformFileError error_code) {
   base::Time now = base::Time::Now();
   bool throttled = now < next_release_time_for_open_filesystem_stat_;
   if (!throttled) {
     next_release_time_for_open_filesystem_stat_ =
         now + base::TimeDelta::FromHours(kMinimumStatsCollectionIntervalHours);
   }
 
 #define REPORT(report_value)                                            \
   UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailLabel,                 \
@@ skipping 16 matching lines @@
       REPORT(kNotFound);
       break;
     case base::PLATFORM_FILE_ERROR_FAILED:
     default:
       REPORT(kUnknownError);
       break;
   }
 #undef REPORT
 }
 
-const UpdateObserverList* SandboxMountPointProvider::GetUpdateObservers(
+const UpdateObserverList* SandboxFileSystemBackend::GetUpdateObservers(
     FileSystemType type) const {
   DCHECK(CanHandleType(type));
   if (type == kFileSystemTypeSyncable)
     return &syncable_update_observers_;
   return &update_observers_;
 }
 
-const AccessObserverList* SandboxMountPointProvider::GetAccessObservers(
+const AccessObserverList* SandboxFileSystemBackend::GetAccessObservers(
     FileSystemType type) const {
   DCHECK(CanHandleType(type));
   return &access_observers_;
 }
 
-void SandboxMountPointProvider::AddFileUpdateObserver(
+void SandboxFileSystemBackend::AddFileUpdateObserver(
     FileSystemType type,
     FileUpdateObserver* observer,
     base::SequencedTaskRunner* task_runner) {
   DCHECK(CanHandleType(type));
   UpdateObserverList* list = &update_observers_;
   if (type == kFileSystemTypeSyncable)
     list = &syncable_update_observers_;
   UpdateObserverList::Source observer_source = list->source();
   observer_source.AddObserver(observer, task_runner);
   *list = UpdateObserverList(observer_source);
 }
 
-void SandboxMountPointProvider::AddFileChangeObserver(
+void SandboxFileSystemBackend::AddFileChangeObserver(
     FileSystemType type,
     FileChangeObserver* observer,
     base::SequencedTaskRunner* task_runner) {
   ChangeObserverList* list = &change_observers_;
   if (type == kFileSystemTypeSyncable)
     list = &syncable_change_observers_;
   ChangeObserverList::Source observer_source = list->source();
   observer_source.AddObserver(observer, task_runner);
   *list = ChangeObserverList(observer_source);
 }
 
-bool SandboxMountPointProvider::IsAccessValid(
+bool SandboxFileSystemBackend::IsAccessValid(
     const FileSystemURL& url) const {
   if (!IsAllowedScheme(url.origin()))
     return false;
 
   if (!CanHandleType(url.type()))
     return false;
 
   if (url.path().ReferencesParent())
     return false;
 
@@ skipping 14 matching lines @@
   }
   for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
     if (filename.value().find(kRestrictedChars[i]) !=
         base::FilePath::StringType::npos)
       return false;
   }
 
   return true;
 }
 
-base::FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
+base::FilePath SandboxFileSystemBackend::GetUsageCachePathForOriginAndType(
     const GURL& origin_url,
     FileSystemType type) {
   base::PlatformFileError error;
   base::FilePath path = GetUsageCachePathForOriginAndType(
       sandbox_sync_file_util(), origin_url, type, &error);
   if (error != base::PLATFORM_FILE_OK)
     return base::FilePath();
   return path;
 }
 
 // static
-base::FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
+base::FilePath SandboxFileSystemBackend::GetUsageCachePathForOriginAndType(
     ObfuscatedFileUtil* sandbox_file_util,
     const GURL& origin_url,
     fileapi::FileSystemType type,
     base::PlatformFileError* error_out) {
   DCHECK(error_out);
   *error_out = base::PLATFORM_FILE_OK;
   base::FilePath base_path = sandbox_file_util->GetDirectoryForOriginAndType(
       origin_url, type, false /* create */, error_out);
   if (*error_out != base::PLATFORM_FILE_OK)
     return base::FilePath();
   return base_path.Append(FileSystemUsageCache::kUsageFileName);
 }
 
-bool SandboxMountPointProvider::IsAllowedScheme(const GURL& url) const {
+bool SandboxFileSystemBackend::IsAllowedScheme(const GURL& url) const {
   // Basically we only accept http or https. We allow file:// URLs
   // only if --allow-file-access-from-files flag is given.
   if (url.SchemeIs("http") || url.SchemeIs("https"))
     return true;
   if (url.SchemeIsFileSystem())
     return url.inner_url() && IsAllowedScheme(*url.inner_url());
 
   for (size_t i = 0;
        i < file_system_options_.additional_allowed_schemes().size();
        ++i) {
     if (url.SchemeIs(
             file_system_options_.additional_allowed_schemes()[i].c_str()))
       return true;
   }
   return false;
 }
 
-ObfuscatedFileUtil* SandboxMountPointProvider::sandbox_sync_file_util() {
+ObfuscatedFileUtil* SandboxFileSystemBackend::sandbox_sync_file_util() {
   DCHECK(sandbox_file_util_.get());
   return static_cast<ObfuscatedFileUtil*>(sandbox_file_util_->sync_file_util());
 }
 
 // static
-void SandboxMountPointProvider::InvalidateUsageCacheOnFileThread(
+void SandboxFileSystemBackend::InvalidateUsageCacheOnFileThread(
     ObfuscatedFileUtil* file_util,
     const GURL& origin,
     FileSystemType type,
     FileSystemUsageCache* usage_cache) {
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath usage_cache_path = GetUsageCachePathForOriginAndType(
       file_util, origin, type, &error);
   if (error == base::PLATFORM_FILE_OK)
     usage_cache->IncrementDirty(usage_cache_path);
 }
 
-int64 SandboxMountPointProvider::RecalculateUsage(FileSystemContext* context,
+int64 SandboxFileSystemBackend::RecalculateUsage(FileSystemContext* context,
                                                   const GURL& origin,
                                                   FileSystemType type) {
   FileSystemOperationContext operation_context(context);
   FileSystemURL url = context->CreateCrackedFileSystemURL(
       origin, type, base::FilePath());
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
       sandbox_sync_file_util()->CreateFileEnumerator(
           &operation_context, url, true));
 
   base::FilePath file_path_each;
   int64 usage = 0;
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     usage += enumerator->Size();
     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
 
   return usage;
 }
 
 }  // namespace fileapi