Convert Media Galleries to use base::File

webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc

 // Copyright 2013 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_file_system_backend_delegate.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 94 matching lines @@
 
  private:
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
 void OpenFileSystemOnFileTaskRunner(
     ObfuscatedFileUtil* file_util,
     const GURL& origin_url,
     FileSystemType type,
     OpenFileSystemMode mode,
-    base::PlatformFileError* error_ptr) {
+    base::File::Error* error_ptr) {
   DCHECK(error_ptr);
   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   file_util->GetDirectoryForOriginAndType(
       origin_url, SandboxFileSystemBackendDelegate::GetTypeString(type),
       create, error_ptr);
-  if (*error_ptr != base::PLATFORM_FILE_OK) {
+  if (*error_ptr != base::File::FILE_OK) {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kCreateDirectoryError,
                               kFileSystemErrorMax);
   } else {
     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.
 }
 
 void DidOpenFileSystem(
     base::WeakPtr<SandboxFileSystemBackendDelegate> delegate,
-    const base::Callback<void(base::PlatformFileError error)>& callback,
-    base::PlatformFileError* error) {
+    const base::Callback<void(base::File::Error error)>& callback,
+    base::File::Error* error) {
   if (delegate.get())
     delegate.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
 }
 
 template <typename T>
 void DeleteSoon(base::SequencedTaskRunner* runner, T* ptr) {
   if (!runner->DeleteSoon(FROM_HERE, ptr))
     delete ptr;
 }
@@ skipping 82 matching lines @@
 SandboxFileSystemBackendDelegate::OriginEnumerator*
 SandboxFileSystemBackendDelegate::CreateOriginEnumerator() {
   return new ObfuscatedOriginEnumerator(obfuscated_file_util());
 }
 
 base::FilePath
 SandboxFileSystemBackendDelegate::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url,
     FileSystemType type,
     bool create) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath path = obfuscated_file_util()->GetDirectoryForOriginAndType(
       origin_url, GetTypeString(type), create, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return base::FilePath();
   return path;
 }
 
 void SandboxFileSystemBackendDelegate::OpenFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback,
     const GURL& root_url) {
   if (!IsAllowedScheme(origin_url)) {
-    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   std::string name = GetFileSystemName(origin_url, type);
 
-  base::PlatformFileError* error_ptr = new base::PlatformFileError;
+  base::File::Error* error_ptr = new base::File::Error;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&OpenFileSystemOnFileTaskRunner,
                  obfuscated_file_util(), origin_url, type, mode,
                  base::Unretained(error_ptr)),
       base::Bind(&DidOpenFileSystem,
                  weak_factory_.GetWeakPtr(),
                  base::Bind(callback, root_url, name),
                  base::Owned(error_ptr)));
 
   io_thread_checker_.DetachFromThread();
   is_filesystem_opened_ = true;
 }
 
 scoped_ptr<FileSystemOperationContext>
 SandboxFileSystemBackendDelegate::CreateFileSystemOperationContext(
     const FileSystemURL& url,
     FileSystemContext* context,
-    base::PlatformFileError* error_code) const {
+    base::File::Error* error_code) const {
   if (!IsAccessValid(url)) {
-    *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
+    *error_code = base::File::FILE_ERROR_SECURITY;
     return scoped_ptr<FileSystemOperationContext>();
   }
 
   const UpdateObserverList* update_observers = GetUpdateObservers(url.type());
   const ChangeObserverList* change_observers = GetChangeObservers(url.type());
   DCHECK(update_observers);
 
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   operation_context->set_update_observers(*update_observers);
@@ skipping 23 matching lines @@
     FileSystemContext* context,
     FileSystemType type) const {
   if (!IsAccessValid(url))
     return scoped_ptr<FileStreamWriter>();
   const UpdateObserverList* observers = GetUpdateObservers(type);
   DCHECK(observers);
   return scoped_ptr<FileStreamWriter>(
       new SandboxFileStreamWriter(context, url, offset, *observers));
 }
 
-base::PlatformFileError
+base::File::Error
 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* file_system_context,
     quota::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   int64 usage = GetOriginUsageOnFileTaskRunner(
       file_system_context, origin_url, type);
   usage_cache()->CloseCacheFiles();
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, GetTypeString(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;
+    return base::File::FILE_OK;
+  return base::File::FILE_ERROR_FAILED;
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner(
     FileSystemType type, std::set<GURL>* origins) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (enumerator->HasFileSystemType(type))
@@ skipping 129 matching lines @@
 }
 
 void SandboxFileSystemBackendDelegate::RegisterQuotaUpdateObserver(
     FileSystemType type) {
   AddFileUpdateObserver(type, quota_observer_.get(), file_task_runner_.get());
 }
 
 void SandboxFileSystemBackendDelegate::InvalidateUsageCache(
     const GURL& origin,
     FileSystemType type) {
-  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  base::File::Error error = base::File::FILE_OK;
   base::FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       obfuscated_file_util(), origin, type, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return;
   usage_cache()->IncrementDirty(usage_file_path);
 }
 
 void SandboxFileSystemBackendDelegate::StickyInvalidateUsageCache(
     const GURL& origin,
     FileSystemType type) {
   sticky_dirty_origins_.insert(std::make_pair(origin, type));
   quota_observer()->SetUsageCacheEnabled(origin, type, false);
   InvalidateUsageCache(origin, type);
@@ skipping 50 matching lines @@
             file_system_options_.additional_allowed_schemes()[i].c_str()))
       return true;
   }
   return false;
 }
 
 base::FilePath
 SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
     const GURL& origin_url,
     FileSystemType type) {
-  base::PlatformFileError error;
+  base::File::Error error;
   base::FilePath path = GetUsageCachePathForOriginAndType(
       obfuscated_file_util(), origin_url, type, &error);
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::File::FILE_OK)
     return base::FilePath();
   return path;
 }
 
 // static
 base::FilePath
 SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
     ObfuscatedFileUtil* sandbox_file_util,
     const GURL& origin_url,
     FileSystemType type,
-    base::PlatformFileError* error_out) {
+    base::File::Error* error_out) {
   DCHECK(error_out);
-  *error_out = base::PLATFORM_FILE_OK;
+  *error_out = base::File::FILE_OK;
   base::FilePath base_path = sandbox_file_util->GetDirectoryForOriginAndType(
       origin_url, GetTypeString(type), false /* create */, error_out);
-  if (*error_out != base::PLATFORM_FILE_OK)
+  if (*error_out != base::File::FILE_OK)
     return base::FilePath();
   return base_path.Append(FileSystemUsageCache::kUsageFileName);
 }
 
 int64 SandboxFileSystemBackendDelegate::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(
       obfuscated_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;
 }
 
 void SandboxFileSystemBackendDelegate::CollectOpenFileSystemMetrics(
-    base::PlatformFileError error_code) {
+    base::File::Error 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,                 \
                             (report_value),                             \
                             kFileSystemErrorMax);                       \
   if (!throttled) {                                                     \
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailNonThrottledLabel,   \
                               (report_value),                           \
                               kFileSystemErrorMax);                     \
   }
 
   switch (error_code) {
-    case base::PLATFORM_FILE_OK:
+    case base::File::FILE_OK:
       REPORT(kOK);
       break;
-    case base::PLATFORM_FILE_ERROR_INVALID_URL:
+    case base::File::FILE_ERROR_INVALID_URL:
       REPORT(kInvalidSchemeError);
       break;
-    case base::PLATFORM_FILE_ERROR_NOT_FOUND:
+    case base::File::FILE_ERROR_NOT_FOUND:
       REPORT(kNotFound);
       break;
-    case base::PLATFORM_FILE_ERROR_FAILED:
+    case base::File::FILE_ERROR_FAILED:
     default:
       REPORT(kUnknownError);
       break;
   }
 #undef REPORT
 }
 
 ObfuscatedFileUtil* SandboxFileSystemBackendDelegate::obfuscated_file_util() {
   return static_cast<ObfuscatedFileUtil*>(sync_file_util());
 }
 
 // Declared in obfuscated_file_util.h.
 // static
 ObfuscatedFileUtil* ObfuscatedFileUtil::CreateForTesting(
     quota::SpecialStoragePolicy* special_storage_policy,
     const base::FilePath& file_system_directory,
     base::SequencedTaskRunner* file_task_runner) {
   return new ObfuscatedFileUtil(special_storage_policy,
                                 file_system_directory,
                                 file_task_runner,
                                 base::Bind(&GetTypeStringForURL),
                                 GetKnownTypeStrings(),
                                 NULL);
 }
 
 }  // namespace fileapi