Convert Media Galleries to use base::File

content/browser/fileapi/file_writer_delegate_unittest.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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 25 matching lines @@
 
 const GURL kOrigin("http://example.com");
 const fileapi::FileSystemType kFileSystemType = fileapi::kFileSystemTypeTest;
 
 const char kData[] = "The quick brown fox jumps over the lazy dog.\n";
 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1;
 
 class Result {
  public:
   Result()
-      : status_(base::PLATFORM_FILE_OK),
+      : status_(base::File::FILE_OK),
         bytes_written_(0),
         write_status_(FileWriterDelegate::SUCCESS_IO_PENDING) {}
 
-  base::PlatformFileError status() const { return status_; }
+  base::File::Error status() const { return status_; }
   int64 bytes_written() const { return bytes_written_; }
   FileWriterDelegate::WriteProgressStatus write_status() const {
     return write_status_;
   }
 
-  void DidWrite(base::PlatformFileError status, int64 bytes,
+  void DidWrite(base::File::Error status, int64 bytes,
                 FileWriterDelegate::WriteProgressStatus write_status) {
     write_status_ = write_status;
-    if (status == base::PLATFORM_FILE_OK) {
+    if (status == base::File::FILE_OK) {
       bytes_written_ += bytes;
       if (write_status_ != FileWriterDelegate::SUCCESS_IO_PENDING)
         base::MessageLoop::current()->Quit();
     } else {
-      EXPECT_EQ(base::PLATFORM_FILE_OK, status_);
+      EXPECT_EQ(base::File::FILE_OK, status_);
       status_ = status;
       base::MessageLoop::current()->Quit();
     }
   }
 
  private:
   // For post-operation status.
-  base::PlatformFileError status_;
+  base::File::Error status_;
   int64 bytes_written_;
   FileWriterDelegate::WriteProgressStatus write_status_;
 };
 
 }  // namespace (anonymous)
 
 class FileWriterDelegateTest : public PlatformTest {
  public:
   FileWriterDelegateTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   int64 usage() {
     return file_system_context_->GetQuotaUtil(kFileSystemType)
         ->GetOriginUsageOnFileTaskRunner(
               file_system_context_.get(), kOrigin, kFileSystemType);
   }
 
   int64 GetFileSizeOnDisk(const char* test_file_path) {
     // There might be in-flight flush/write.
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&base::DoNothing));
     base::RunLoop().RunUntilIdle();
 
     FileSystemURL url = GetFileSystemURL(test_file_path);
-    base::PlatformFileInfo file_info;
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    base::File::Info file_info;
+    EXPECT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::GetMetadata(
                   file_system_context_, url, &file_info));
     return file_info.size;
   }
 
   FileSystemURL GetFileSystemURL(const char* file_name) const {
     return file_system_context_->CreateCrackedFileSystemURL(
         kOrigin, kFileSystemType, base::FilePath().FromUTF8Unsafe(file_name));
   }
 
@@ skipping 104 matching lines @@
     const std::string& scheme) {
   return new FileWriterDelegateTestJob(
       request, network_delegate, FileWriterDelegateTest::content_);
 }
 
 void FileWriterDelegateTest::SetUp() {
   ASSERT_TRUE(dir_.CreateUniqueTempDir());
 
   file_system_context_ = CreateFileSystemContextForTesting(
       NULL, dir_.path());
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::CreateFile(
                 file_system_context_, GetFileSystemURL("test")));
   net::URLRequest::Deprecated::RegisterProtocolFactory("blob", &Factory);
 }
 
 void FileWriterDelegateTest::TearDown() {
   net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL);
   file_system_context_ = NULL;
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
   PrepareForWrite("test", kBlobURL, 0, kint64max);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
 
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kDataSize, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
   EXPECT_EQ(kDataSize, result.bytes_written());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+  EXPECT_EQ(base::File::FILE_OK, result.status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   const GURL kBlobURL("blob:just");
   content_ = kData;
   const int64 kAllowedGrowth = kDataSize;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+  EXPECT_EQ(base::File::FILE_OK, result.status());
 }
 
 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) {
   const GURL kBlobURL("blob:failure");
   content_ = kData;
   const int64 kAllowedGrowth = kDataSize - 1;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result.status());
+  EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   const GURL kBlobURL("blob:zero");
   content_ = "";
   int64 kAllowedGrowth = 0;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+  EXPECT_EQ(base::File::FILE_OK, result.status());
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
   scoped_ptr<FileWriterDelegate> file_writer_delegate2;
   scoped_ptr<net::URLRequest> request2;
 
-  ASSERT_EQ(base::PLATFORM_FILE_OK,
+  ASSERT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::CreateFile(
                 file_system_context_, GetFileSystemURL("test2")));
 
   const GURL kBlobURL("blob:nolimitconcurrent");
   const GURL kBlobURL2("blob:nolimitconcurrent2");
   content_ = kData;
 
   PrepareForWrite("test", kBlobURL, 0, kint64max);
 
   // Credate another FileWriterDelegate for concurrent write.
@@ skipping 12 matching lines @@
 
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2.write_status());
   file_writer_delegate_.reset();
   file_writer_delegate2.reset();
 
   ASSERT_EQ(kDataSize * 2, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test") + GetFileSizeOnDisk("test2"), usage());
 
   EXPECT_EQ(kDataSize, result.bytes_written());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+  EXPECT_EQ(base::File::FILE_OK, result.status());
   EXPECT_EQ(kDataSize, result2.bytes_written());
-  EXPECT_EQ(base::PLATFORM_FILE_OK, result2.status());
+  EXPECT_EQ(base::File::FILE_OK, result2.status());
 }
 
 TEST_F(FileWriterDelegateTest, WritesWithQuotaAndOffset) {
   const GURL kBlobURL("blob:failure-with-updated-quota");
   content_ = kData;
 
   // Writing kDataSize (=45) bytes data while allowed_growth is 100.
   int64 offset = 0;
   int64 allowed_growth = 100;
   ASSERT_LT(kDataSize, allowed_growth);
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     ASSERT_EQ(0, usage());
     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     ASSERT_EQ(kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
-    EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+    EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite kDataSize bytes data while allowed_growth is 20.
   offset = 0;
   allowed_growth = 20;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     EXPECT_EQ(kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
-    EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+    EXPECT_EQ(base::File::FILE_OK, result.status());
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   }
 
   // Trying to write kDataSize bytes data from offset 25 while
   // allowed_growth is 55.
   offset = 25;
   allowed_growth = 55;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(offset + kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
-    EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+    EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite 45 bytes data while allowed_growth is -20.
   offset = 0;
   allowed_growth = -20;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
   int64 pre_write_usage = GetFileSizeOnDisk("test");
 
   {
     Result result;
     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
-    EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
+    EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite 45 bytes data with offset pre_write_usage - 20,
   // while allowed_growth is 10.
   const int kOverlap = 20;
   offset = pre_write_usage - kOverlap;
   allowed_growth = 10;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage + allowed_growth, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written());
-    EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result.status());
+    EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   }
 }
 
 }  // namespace content