Convert Media Galleries to use base::File

chrome/browser/sync_file_system/local/canned_syncable_file_system.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 "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
+#include "base/files/file.h"
 #include "base/guid.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/sync_file_system/file_change.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "content/public/test/test_file_system_options.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/blob/mock_blob_url_request_context.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/quota/mock_special_storage_policy.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
-using base::PlatformFileError;
+using base::File;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemOperationRunner;
 using fileapi::FileSystemURL;
 using fileapi::FileSystemURLSet;
 using quota::QuotaManager;
 using webkit_blob::MockBlobURLRequestContext;
 using webkit_blob::ScopedTextBlob;
 
 namespace sync_file_system {
 
@@ skipping 45 matching lines @@
     base::SingleThreadTaskRunner* runner2) {
   ASSERT_TRUE(runner1 != NULL);
   ASSERT_TRUE(runner2 != NULL);
   runner1->PostTask(FROM_HERE,
                     base::Bind(&EnsureRunningOn, make_scoped_refptr(runner2)));
 }
 
 void OnCreateSnapshotFileAndVerifyData(
     const std::string& expected_data,
     const CannedSyncableFileSystem::StatusCallback& callback,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& file_info,
+    base::File::Error result,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& /* file_ref */) {
-  if (result != base::PLATFORM_FILE_OK) {
+  if (result != base::File::FILE_OK) {
     callback.Run(result);
     return;
   }
   EXPECT_EQ(expected_data.size(), static_cast<size_t>(file_info.size));
   std::string data;
   const bool read_status = base::ReadFileToString(platform_path, &data);
   EXPECT_TRUE(read_status);
   EXPECT_EQ(expected_data, data);
   callback.Run(result);
 }
 
 void OnCreateSnapshotFile(
-    base::PlatformFileInfo* file_info_out,
+    base::File::Info* file_info_out,
     base::FilePath* platform_path_out,
     const CannedSyncableFileSystem::StatusCallback& callback,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& file_info,
+    base::File::Error result,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   DCHECK(!file_ref.get());
   DCHECK(file_info_out);
   DCHECK(platform_path_out);
   *file_info_out = file_info;
   *platform_path_out = platform_path;
   callback.Run(result);
 }
 
 void OnReadDirectory(
     CannedSyncableFileSystem::FileEntryList* entries_out,
     const CannedSyncableFileSystem::StatusCallback& callback,
-    base::PlatformFileError error,
+    base::File::Error error,
     const fileapi::FileSystemOperation::FileEntryList& entries,
     bool has_more) {
   DCHECK(entries_out);
   entries_out->reserve(entries_out->size() + entries.size());
   std::copy(entries.begin(), entries.end(), std::back_inserter(*entries_out));
 
   if (!has_more)
     callback.Run(error);
 }
 
@@ skipping 12 matching lines @@
   ~WriteHelper() {
     if (request_context_) {
       base::MessageLoop::current()->DeleteSoon(FROM_HERE,
                                                request_context_.release());
     }
   }
 
   ScopedTextBlob* scoped_text_blob() const { return blob_data_.get(); }
 
   void DidWrite(const base::Callback<void(int64 result)>& completion_callback,
-                PlatformFileError error, int64 bytes, bool complete) {
-    if (error == base::PLATFORM_FILE_OK) {
+                File::Error error, int64 bytes, bool complete) {
+    if (error == base::File::FILE_OK) {
       bytes_written_ += bytes;
       if (!complete)
         return;
     }
-    completion_callback.Run(error == base::PLATFORM_FILE_OK
-                            ? bytes_written_ : static_cast<int64>(error));
+    completion_callback.Run(error == base::File::FILE_OK ?
+                            bytes_written_ : static_cast<int64>(error));
   }
 
  private:
   int64 bytes_written_;
   scoped_ptr<MockBlobURLRequestContext> request_context_;
   scoped_ptr<ScopedTextBlob> blob_data_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteHelper);
 };
 
@@ skipping 14 matching lines @@
 }
 
 }  // namespace
 
 CannedSyncableFileSystem::CannedSyncableFileSystem(
     const GURL& origin,
     base::SingleThreadTaskRunner* io_task_runner,
     base::SingleThreadTaskRunner* file_task_runner)
     : origin_(origin),
       type_(fileapi::kFileSystemTypeSyncable),
-      result_(base::PLATFORM_FILE_OK),
+      result_(base::File::FILE_OK),
       sync_status_(sync_file_system::SYNC_STATUS_OK),
       io_task_runner_(io_task_runner),
       file_task_runner_(file_task_runner),
       is_filesystem_set_up_(false),
       is_filesystem_opened_(false),
       sync_status_observers_(new ObserverList) {
 }
 
 CannedSyncableFileSystem::~CannedSyncableFileSystem() {}
 
@@ skipping 41 matching lines @@
 }
 
 FileSystemURL CannedSyncableFileSystem::URL(const std::string& path) const {
   EXPECT_TRUE(is_filesystem_set_up_);
   EXPECT_FALSE(root_url_.is_empty());
 
   GURL url(root_url_.spec() + path);
   return file_system_context_->CrackURL(url);
 }
 
-PlatformFileError CannedSyncableFileSystem::OpenFileSystem() {
+File::Error CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
 
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoOpenFileSystem,
                  base::Unretained(this),
                  base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                             base::Unretained(this),
                             base::MessageLoopProxy::current())));
   base::MessageLoop::current()->Run();
@@ skipping 27 matching lines @@
                        sync_context->io_task_runner_.get());
   sync_context->MaybeInitializeFileSystemContext(
       origin_,
       file_system_context_.get(),
       base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
   return sync_status_;
 }
 
-PlatformFileError CannedSyncableFileSystem::CreateDirectory(
+File::Error CannedSyncableFileSystem::CreateDirectory(
     const FileSystemURL& url) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateDirectory,
                  base::Unretained(this),
                  url));
 }
 
-PlatformFileError CannedSyncableFileSystem::CreateFile(
-    const FileSystemURL& url) {
-  return RunOnThread<PlatformFileError>(
+File::Error CannedSyncableFileSystem::CreateFile(const FileSystemURL& url) {
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateFile,
                  base::Unretained(this),
                  url));
 }
 
-PlatformFileError CannedSyncableFileSystem::Copy(
+File::Error CannedSyncableFileSystem::Copy(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCopy,
                  base::Unretained(this),
                  src_url,
                  dest_url));
 }
 
-PlatformFileError CannedSyncableFileSystem::Move(
+File::Error CannedSyncableFileSystem::Move(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoMove,
                  base::Unretained(this),
                  src_url,
                  dest_url));
 }
 
-PlatformFileError CannedSyncableFileSystem::TruncateFile(
+File::Error CannedSyncableFileSystem::TruncateFile(
     const FileSystemURL& url, int64 size) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTruncateFile,
                  base::Unretained(this),
                  url,
                  size));
 }
 
-PlatformFileError CannedSyncableFileSystem::TouchFile(
+File::Error CannedSyncableFileSystem::TouchFile(
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTouchFile,
                  base::Unretained(this),
                  url,
                  last_access_time,
                  last_modified_time));
 }
 
-PlatformFileError CannedSyncableFileSystem::Remove(
+File::Error CannedSyncableFileSystem::Remove(
     const FileSystemURL& url, bool recursive) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoRemove,
                  base::Unretained(this),
                  url,
                  recursive));
 }
 
-PlatformFileError CannedSyncableFileSystem::FileExists(
+File::Error CannedSyncableFileSystem::FileExists(
     const FileSystemURL& url) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoFileExists,
                  base::Unretained(this),
                  url));
 }
 
-PlatformFileError CannedSyncableFileSystem::DirectoryExists(
+File::Error CannedSyncableFileSystem::DirectoryExists(
     const FileSystemURL& url) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoDirectoryExists,
                  base::Unretained(this),
                  url));
 }
 
-PlatformFileError CannedSyncableFileSystem::VerifyFile(
+File::Error CannedSyncableFileSystem::VerifyFile(
     const FileSystemURL& url,
     const std::string& expected_data) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoVerifyFile,
                  base::Unretained(this),
                  url,
                  expected_data));
 }
 
-PlatformFileError CannedSyncableFileSystem::GetMetadataAndPlatformPath(
+File::Error CannedSyncableFileSystem::GetMetadataAndPlatformPath(
     const FileSystemURL& url,
-    base::PlatformFileInfo* info,
+    base::File::Info* info,
     base::FilePath* platform_path) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetMetadataAndPlatformPath,
                  base::Unretained(this),
                  url,
                  info,
                  platform_path));
 }
 
-PlatformFileError CannedSyncableFileSystem::ReadDirectory(
+File::Error CannedSyncableFileSystem::ReadDirectory(
     const fileapi::FileSystemURL& url,
     FileEntryList* entries) {
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoReadDirectory,
           base::Unretained(this),
           url,
           entries));
 }
 
 int64 CannedSyncableFileSystem::Write(
     net::URLRequestContext* url_request_context,
@@ skipping 11 matching lines @@
 int64 CannedSyncableFileSystem::WriteString(
     const FileSystemURL& url, const std::string& data) {
   return RunOnThread<int64>(io_task_runner_.get(),
                             FROM_HERE,
                             base::Bind(&CannedSyncableFileSystem::DoWriteString,
                                        base::Unretained(this),
                                        url,
                                        data));
 }
 
-PlatformFileError CannedSyncableFileSystem::DeleteFileSystem() {
+File::Error CannedSyncableFileSystem::DeleteFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
-  return RunOnThread<PlatformFileError>(
+  return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileSystemContext::DeleteFileSystem,
                  file_system_context_,
                  origin_,
                  type_));
 }
 
 quota::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota(
     int64* usage, int64* quota) {
@@ skipping 151 matching lines @@
     const StatusCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->CreateSnapshotFile(
       url,
       base::Bind(&OnCreateSnapshotFileAndVerifyData, expected_data, callback));
 }
 
 void CannedSyncableFileSystem::DoGetMetadataAndPlatformPath(
     const FileSystemURL& url,
-    base::PlatformFileInfo* info,
+    base::File::Info* info,
     base::FilePath* platform_path,
     const StatusCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->CreateSnapshotFile(
       url, base::Bind(&OnCreateSnapshotFile, info, platform_path, callback));
 }
 
 void CannedSyncableFileSystem::DoReadDirectory(
     const FileSystemURL& url,
@@ skipping 42 matching lines @@
   EXPECT_TRUE(is_filesystem_opened_);
   quota_manager_->GetUsageAndQuota(
       origin_, storage_type(),
       base::Bind(&DidGetUsageAndQuota, callback, usage, quota));
 }
 
 void CannedSyncableFileSystem::DidOpenFileSystem(
     base::SingleThreadTaskRunner* original_task_runner,
     const GURL& root,
     const std::string& name,
-    PlatformFileError result) {
+    File::Error result) {
   if (io_task_runner_->RunsTasksOnCurrentThread()) {
     EXPECT_FALSE(is_filesystem_opened_);
     is_filesystem_opened_ = true;
   }
   if (!original_task_runner->RunsTasksOnCurrentThread()) {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                    base::Unretained(this),
@@ skipping 11 matching lines @@
   sync_status_ = status;
   base::MessageLoop::current()->Quit();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system