Convert Media Galleries to use base::File

webkit/browser/fileapi/quota/quota_reservation_manager_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 "webkit/browser/fileapi/quota/quota_reservation_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
+#include "base/files/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/quota/open_file_handle.h"
 #include "webkit/browser/fileapi/quota/quota_reservation.h"
 
 namespace fileapi {
 
 namespace {
 
 const char kOrigin[] = "http://example.com";
 const FileSystemType kType = kFileSystemTypeTemporary;
 const int64 kInitialFileSize = 1;
 
 typedef QuotaReservationManager::ReserveQuotaCallback ReserveQuotaCallback;
 
 int64 GetFileSize(const base::FilePath& path) {
   int64 size = 0;
   base::GetFileSize(path, &size);
   return size;
 }
 
 void SetFileSize(const base::FilePath& path, int64 size) {
-  bool created = false;
-  base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
-  base::PlatformFile file = CreatePlatformFile(
-      path,
-      base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE,
-      &created, &error);
-  ASSERT_EQ(base::PLATFORM_FILE_OK, error);
-  ASSERT_TRUE(base::TruncatePlatformFile(file, size));
-  ASSERT_TRUE(base::ClosePlatformFile(file));
+  base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
+  ASSERT_TRUE(file.IsValid());
+  ASSERT_TRUE(file.SetLength(size));
 }
 
 class FakeBackend : public QuotaReservationManager::QuotaBackend {
  public:
   FakeBackend()
       : on_memory_usage_(kInitialFileSize),
         on_disk_usage_(kInitialFileSize) {}
   virtual ~FakeBackend() {}
 
   virtual void ReserveQuota(const GURL& origin,
                             FileSystemType type,
                             int64 delta,
                             const ReserveQuotaCallback& callback) OVERRIDE {
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ += delta;
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
-        base::Bind(base::IgnoreResult(callback), base::PLATFORM_FILE_OK));
+        base::Bind(base::IgnoreResult(callback), base::File::FILE_OK));
   }
 
   virtual void ReleaseReservedQuota(const GURL& origin,
                                     FileSystemType type,
                                     int64 size) OVERRIDE {
     EXPECT_LE(0, size);
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ -= size;
   }
@@ skipping 81 matching lines @@
   }
 
  private:
   scoped_ptr<OpenFileHandle> handle_;
   base::FilePath path_;
   int64 max_written_offset_;
   int64 append_mode_write_amount_;
   bool dirty_;
 };
 
-void ExpectSuccess(bool* done, base::PlatformFileError error) {
+void ExpectSuccess(bool* done, base::File::Error error) {
   EXPECT_FALSE(*done);
   *done = true;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
 }
 
 void RefreshReservation(QuotaReservation* reservation, int64 size) {
   DCHECK(reservation);
 
   bool done = false;
   reservation->RefreshReservation(size, base::Bind(&ExpectSuccess, &done));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(done);
 }
@@ skipping 181 matching lines @@
 
   EXPECT_EQ(kInitialFileSize + 10, GetFileSize(file_path()));
   EXPECT_EQ(kInitialFileSize + 15 + 20, fake_backend()->on_memory_usage());
   EXPECT_EQ(kInitialFileSize + 10, fake_backend()->on_disk_usage());
 
   reservation2 = NULL;
   EXPECT_EQ(kInitialFileSize + 10, fake_backend()->on_memory_usage());
 }
 
 }  // namespace fileapi