Switch to standard integer types in content/browser/.

content/browser/quota/quota_reservation_manager_unittest.cc

 // Copyright 2014 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 "storage/browser/fileapi/quota/quota_reservation_manager.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "storage/browser/fileapi/quota/open_file_handle.h"
 #include "storage/browser/fileapi/quota/quota_reservation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::kFileSystemTypeTemporary;
 using storage::OpenFileHandle;
 using storage::QuotaReservation;
 using storage::QuotaReservationManager;
 
 namespace content {
 
 namespace {
 
 const char kOrigin[] = "http://example.com";
 const storage::FileSystemType kType = kFileSystemTypeTemporary;
-const int64 kInitialFileSize = 1;
+const int64_t kInitialFileSize = 1;
 
 typedef QuotaReservationManager::ReserveQuotaCallback ReserveQuotaCallback;
 
-int64 GetFileSize(const base::FilePath& path) {
-  int64 size = 0;
+int64_t GetFileSize(const base::FilePath& path) {
+  int64_t size = 0;
   base::GetFileSize(path, &size);
   return size;
 }
 
-void SetFileSize(const base::FilePath& path, int64 size) {
+void SetFileSize(const base::FilePath& path, int64_t size) {
   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) {}
   ~FakeBackend() override {}
 
   void ReserveQuota(const GURL& origin,
                     storage::FileSystemType type,
-                    int64 delta,
+                    int64_t delta,
                     const ReserveQuotaCallback& callback) override {
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ += delta;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(callback), base::File::FILE_OK, delta));
   }
 
   void ReleaseReservedQuota(const GURL& origin,
                             storage::FileSystemType type,
-                            int64 size) override {
+                            int64_t size) override {
     EXPECT_LE(0, size);
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ -= size;
   }
 
   void CommitQuotaUsage(const GURL& origin,
                         storage::FileSystemType type,
-                        int64 delta) override {
+                        int64_t delta) override {
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_disk_usage_ += delta;
     on_memory_usage_ += delta;
   }
 
   void IncrementDirtyCount(const GURL& origin,
                            storage::FileSystemType type) override {}
   void DecrementDirtyCount(const GURL& origin,
                            storage::FileSystemType type) override {}
 
-  int64 on_memory_usage() { return on_memory_usage_; }
-  int64 on_disk_usage() { return on_disk_usage_; }
+  int64_t on_memory_usage() { return on_memory_usage_; }
+  int64_t on_disk_usage() { return on_disk_usage_; }
 
  private:
-  int64 on_memory_usage_;
-  int64 on_disk_usage_;
+  int64_t on_memory_usage_;
+  int64_t on_disk_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeBackend);
 };
 
 class FakeWriter {
  public:
   explicit FakeWriter(scoped_ptr<OpenFileHandle> handle)
       : handle_(handle.Pass()),
         path_(handle_->platform_path()),
         max_written_offset_(handle_->GetEstimatedFileSize()),
         append_mode_write_amount_(0),
         dirty_(false) {
   }
 
   ~FakeWriter() {
     if (handle_)
       EXPECT_FALSE(dirty_);
   }
 
-  int64 Truncate(int64 length) {
-    int64 consumed = 0;
+  int64_t Truncate(int64_t length) {
+    int64_t consumed = 0;
 
     if (max_written_offset_ < length) {
       consumed = length - max_written_offset_;
       max_written_offset_ = length;
     }
     SetFileSize(path_, length);
     return consumed;
   }
 
-  int64 Write(int64 max_offset) {
+  int64_t Write(int64_t max_offset) {
     dirty_ = true;
 
-    int64 consumed = 0;
+    int64_t consumed = 0;
     if (max_written_offset_ < max_offset) {
       consumed = max_offset - max_written_offset_;
       max_written_offset_ = max_offset;
     }
     if (GetFileSize(path_) < max_offset)
       SetFileSize(path_, max_offset);
     return consumed;
   }
 
-  int64 Append(int64 amount) {
+  int64_t Append(int64_t amount) {
     dirty_ = true;
     append_mode_write_amount_ += amount;
     SetFileSize(path_, GetFileSize(path_) + amount);
     return amount;
   }
 
   void ReportUsage() {
     handle_->UpdateMaxWrittenOffset(max_written_offset_);
     handle_->AddAppendModeWriteAmount(append_mode_write_amount_);
     max_written_offset_ = handle_->GetEstimatedFileSize();
     append_mode_write_amount_ = 0;
     dirty_ = false;
   }
 
   void ClearWithoutUsageReport() {
     handle_.reset();
   }
 
  private:
   scoped_ptr<OpenFileHandle> handle_;
   base::FilePath path_;
-  int64 max_written_offset_;
-  int64 append_mode_write_amount_;
+  int64_t max_written_offset_;
+  int64_t append_mode_write_amount_;
   bool dirty_;
 };
 
 void ExpectSuccess(bool* done, base::File::Error error) {
   EXPECT_FALSE(*done);
   *done = true;
   EXPECT_EQ(base::File::FILE_OK, error);
 }
 
-void RefreshReservation(QuotaReservation* reservation, int64 size) {
+void RefreshReservation(QuotaReservation* reservation, int64_t size) {
   DCHECK(reservation);
 
   bool done = false;
   reservation->RefreshReservation(size, base::Bind(&ExpectSuccess, &done));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(done);
 }
 
 }  // namespace
 
@@ skipping 33 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(QuotaReservationManagerTest);
 };
 
 TEST_F(QuotaReservationManagerTest, BasicTest) {
   scoped_refptr<QuotaReservation> reservation =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 3);
-    int64 cached_reserved_quota = reservation->remaining_quota();
+    int64_t cached_reserved_quota = reservation->remaining_quota();
     FakeWriter writer(reservation->GetOpenFileHandle(file_path()));
 
     cached_reserved_quota -= writer.Write(kInitialFileSize + 10);
     EXPECT_LE(0, cached_reserved_quota);
     cached_reserved_quota -= writer.Append(20);
     EXPECT_LE(0, cached_reserved_quota);
 
     writer.ReportUsage();
   }
 
@@ skipping 20 matching lines @@
 
   EXPECT_EQ(3, fake_backend()->on_memory_usage());
 }
 
 TEST_F(QuotaReservationManagerTest, MultipleWriter) {
   scoped_refptr<QuotaReservation> reservation =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 30 + 40 + 5);
-    int64 cached_reserved_quota = reservation->remaining_quota();
+    int64_t cached_reserved_quota = reservation->remaining_quota();
     FakeWriter writer1(reservation->GetOpenFileHandle(file_path()));
     FakeWriter writer2(reservation->GetOpenFileHandle(file_path()));
     FakeWriter writer3(reservation->GetOpenFileHandle(file_path()));
 
     cached_reserved_quota -= writer1.Write(kInitialFileSize + 10);
     EXPECT_LE(0, cached_reserved_quota);
     cached_reserved_quota -= writer2.Write(kInitialFileSize + 20);
     cached_reserved_quota -= writer3.Append(30);
     EXPECT_LE(0, cached_reserved_quota);
     cached_reserved_quota -= writer3.Append(40);
@@ skipping 11 matching lines @@
 
   reservation = NULL;
 
   EXPECT_EQ(kInitialFileSize + 20 + 30 + 40, fake_backend()->on_disk_usage());
 }
 
 TEST_F(QuotaReservationManagerTest, MultipleClient) {
   scoped_refptr<QuotaReservation> reservation1 =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
   RefreshReservation(reservation1.get(), 10);
-  int64 cached_reserved_quota1 = reservation1->remaining_quota();
+  int64_t cached_reserved_quota1 = reservation1->remaining_quota();
 
   scoped_refptr<QuotaReservation> reservation2 =
       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
   RefreshReservation(reservation2.get(), 20);
-  int64 cached_reserved_quota2 = reservation2->remaining_quota();
+  int64_t cached_reserved_quota2 = reservation2->remaining_quota();
 
   scoped_ptr<FakeWriter> writer1(
       new FakeWriter(reservation1->GetOpenFileHandle(file_path())));
 
   scoped_ptr<FakeWriter> writer2(
       new FakeWriter(reservation2->GetOpenFileHandle(file_path())));
 
   cached_reserved_quota1 -= writer1->Write(kInitialFileSize + 10);
   EXPECT_LE(0, cached_reserved_quota1);
 
@@ skipping 44 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 content