Switch to standard integer types in content/browser/.

content/browser/fileapi/file_system_operation_impl_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 "storage/browser/fileapi/file_system_operation_impl.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/fileapi/mock_file_change_observer.h"
 #include "content/browser/fileapi/mock_file_update_observer.h"
 #include "content/browser/quota/mock_quota_manager.h"
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/public/test/async_file_test_helper.h"
@@ skipping 127 matching lines @@
   }
 
   FileSystemURL CreateDirectory(const std::string& path) {
     FileSystemURL url = URLForPath(path);
     EXPECT_EQ(base::File::FILE_OK,
               file_util()->CreateDirectory(NewContext().get(), url,
                                            false /* exclusive */, true));
     return url;
   }
 
-  int64 GetFileSize(const std::string& path) {
+  int64_t GetFileSize(const std::string& path) {
     base::File::Info info;
     EXPECT_TRUE(base::GetFileInfo(PlatformPath(path), &info));
     return info.size;
   }
 
   // Callbacks for recording test results.
   FileSystemOperation::StatusCallback RecordStatusCallback(
       const base::Closure& closure,
       base::File::Error* status) {
     return base::Bind(&FileSystemOperationImplTest::DidFinish,
@@ skipping 62 matching lines @@
       const base::File::Info& info,
       const base::FilePath& platform_path,
       const scoped_refptr<ShareableFileReference>& shareable_file_ref) {
     info_ = info;
     path_ = platform_path;
     *status = actual;
     shareable_file_ref_ = shareable_file_ref;
     closure.Run();
   }
 
-  int64 GetDataSizeOnDisk() {
+  int64_t GetDataSizeOnDisk() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
         sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
-  void GetUsageAndQuota(int64* usage, int64* quota) {
+  void GetUsageAndQuota(int64_t* usage, int64_t* quota) {
     storage::QuotaStatusCode status =
         AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(),
                                               sandbox_file_system_.origin(),
                                               sandbox_file_system_.type(),
                                               usage,
                                               quota);
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(storage::kQuotaStatusOk, status);
   }
 
-  int64 ComputePathCost(const FileSystemURL& url) {
-    int64 base_usage;
+  int64_t ComputePathCost(const FileSystemURL& url) {
+    int64_t base_usage;
     GetUsageAndQuota(&base_usage, NULL);
 
     AsyncFileTestHelper::CreateFile(
         sandbox_file_system_.file_system_context(), url);
     EXPECT_EQ(base::File::FILE_OK, Remove(url, false /* recursive */));
 
     change_observer()->ResetCount();
 
-    int64 total_usage;
+    int64_t total_usage;
     GetUsageAndQuota(&total_usage, NULL);
     return total_usage - base_usage;
   }
 
   void GrantQuotaForCurrentUsage() {
-    int64 usage;
+    int64_t usage;
     GetUsageAndQuota(&usage, NULL);
     quota_manager()->SetQuota(sandbox_file_system_.origin(),
                               sandbox_file_system_.storage_type(),
                               usage);
   }
 
-  int64 GetUsage() {
-    int64 usage = 0;
+  int64_t GetUsage() {
+    int64_t usage = 0;
     GetUsageAndQuota(&usage, NULL);
     return usage;
   }
 
-  void AddQuota(int64 quota_delta) {
-    int64 quota;
+  void AddQuota(int64_t quota_delta) {
+    int64_t quota;
     GetUsageAndQuota(NULL, &quota);
     quota_manager()->SetQuota(sandbox_file_system_.origin(),
                               sandbox_file_system_.storage_type(),
                               quota + quota_delta);
   }
 
   base::File::Error Move(
       const FileSystemURL& src,
       const FileSystemURL& dest,
       storage::FileSystemOperation::CopyOrMoveOption option) {
@@ skipping 402 matching lines @@
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopyFailureByQuota) {
   FileSystemURL src_dir(CreateDirectory("src"));
   FileSystemURL src_file(CreateFile("src/file"));
   FileSystemURL dest_dir(CreateDirectory("dest"));
   EXPECT_EQ(base::File::FILE_OK, Truncate(src_file, 6));
   EXPECT_EQ(6, GetFileSize("src/file"));
 
   FileSystemURL dest_file(URLForPath("dest/file"));
-  int64 dest_path_cost = ComputePathCost(dest_file);
+  int64_t dest_path_cost = ComputePathCost(dest_file);
   GrantQuotaForCurrentUsage();
   AddQuota(6 + dest_path_cost - 1);
 
   EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE,
             Copy(src_file, dest_file, FileSystemOperation::OPTION_NONE));
   EXPECT_FALSE(FileExists("dest/file"));
 }
 
 TEST_F(FileSystemOperationImplTest, TestCopySuccessSrcFileAndOverwrite) {
   FileSystemURL src_file(CreateFile("src"));
@@ skipping 95 matching lines @@
 
 TEST_F(FileSystemOperationImplTest, TestCopyInForeignFileSuccess) {
   base::FilePath src_local_disk_file_path;
   base::CreateTemporaryFile(&src_local_disk_file_path);
   const char test_data[] = "foo";
   int data_size = arraysize(test_data);
   base::WriteFile(src_local_disk_file_path, test_data, data_size);
 
   FileSystemURL dest_dir(CreateDirectory("dest"));
 
-  int64 before_usage;
+  int64_t before_usage;
   GetUsageAndQuota(&before_usage, NULL);
 
   // Check that the file copied and corresponding usage increased.
   EXPECT_EQ(
       base::File::FILE_OK,
       CopyInForeignFile(src_local_disk_file_path, URLForPath("dest/file")));
 
   EXPECT_EQ(1, change_observer()->create_file_count());
   EXPECT_TRUE(FileExists("dest/file"));
-  int64 after_usage;
+  int64_t after_usage;
   GetUsageAndQuota(&after_usage, NULL);
   EXPECT_GT(after_usage, before_usage);
 
   // Compare contents of src and copied file.
   char buffer[100];
   EXPECT_EQ(data_size, base::ReadFile(PlatformPath("dest/file"),
                                       buffer, data_size));
   for (int i = 0; i < data_size; ++i)
     EXPECT_EQ(test_data[i], buffer[i]);
 }
@@ skipping 365 matching lines @@
   FileSystemURL grandchild_file2(CreateFile("src/dir/file2"));
 
   int total_path_cost = GetUsage();
   EXPECT_EQ(0, GetDataSizeOnDisk());
 
   EXPECT_EQ(base::File::FILE_OK, Truncate(child_file1, 5000));
   EXPECT_EQ(base::File::FILE_OK, Truncate(child_file2, 400));
   EXPECT_EQ(base::File::FILE_OK, Truncate(grandchild_file1, 30));
   EXPECT_EQ(base::File::FILE_OK, Truncate(grandchild_file2, 2));
 
-  const int64 all_file_size = 5000 + 400 + 30 + 2;
+  const int64_t all_file_size = 5000 + 400 + 30 + 2;
   EXPECT_EQ(all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(all_file_size + total_path_cost, GetUsage());
 
   EXPECT_EQ(base::File::FILE_OK,
             Move(src, dest, FileSystemOperation::OPTION_NONE));
 
   EXPECT_FALSE(DirectoryExists("src/dir"));
   EXPECT_FALSE(FileExists("src/dir/file2"));
   EXPECT_TRUE(DirectoryExists("dest/dir"));
   EXPECT_TRUE(FileExists("dest/dir/file2"));
 
   EXPECT_EQ(all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(all_file_size + total_path_cost - src_path_cost,
             GetUsage());
 }
 
 TEST_F(FileSystemOperationImplTest,
        TestCopySuccessSrcDirRecursiveWithQuota) {
   FileSystemURL src(CreateDirectory("src"));
   FileSystemURL dest1(CreateDirectory("dest1"));
   FileSystemURL dest2(CreateDirectory("dest2"));
 
-  int64 usage = GetUsage();
+  int64_t usage = GetUsage();
   FileSystemURL child_file1(CreateFile("src/file1"));
   FileSystemURL child_file2(CreateFile("src/file2"));
   FileSystemURL child_dir(CreateDirectory("src/dir"));
-  int64 child_path_cost = GetUsage() - usage;
+  int64_t child_path_cost = GetUsage() - usage;
   usage += child_path_cost;
 
   FileSystemURL grandchild_file1(CreateFile("src/dir/file1"));
   FileSystemURL grandchild_file2(CreateFile("src/dir/file2"));
-  int64 total_path_cost = GetUsage();
-  int64 grandchild_path_cost = total_path_cost - usage;
+  int64_t total_path_cost = GetUsage();
+  int64_t grandchild_path_cost = total_path_cost - usage;
 
   EXPECT_EQ(0, GetDataSizeOnDisk());
 
   EXPECT_EQ(base::File::FILE_OK, Truncate(child_file1, 8000));
   EXPECT_EQ(base::File::FILE_OK, Truncate(child_file2, 700));
   EXPECT_EQ(base::File::FILE_OK, Truncate(grandchild_file1, 60));
   EXPECT_EQ(base::File::FILE_OK, Truncate(grandchild_file2, 5));
 
-  const int64 child_file_size = 8000 + 700;
-  const int64 grandchild_file_size = 60 + 5;
-  const int64 all_file_size = child_file_size + grandchild_file_size;
-  int64 expected_usage = all_file_size + total_path_cost;
+  const int64_t child_file_size = 8000 + 700;
+  const int64_t grandchild_file_size = 60 + 5;
+  const int64_t all_file_size = child_file_size + grandchild_file_size;
+  int64_t expected_usage = all_file_size + total_path_cost;
 
   usage = GetUsage();
   EXPECT_EQ(all_file_size, GetDataSizeOnDisk());
   EXPECT_EQ(expected_usage, usage);
 
   EXPECT_EQ(base::File::FILE_OK,
             Copy(src, dest1, FileSystemOperation::OPTION_NONE));
 
   expected_usage += all_file_size + child_path_cost + grandchild_path_cost;
   EXPECT_TRUE(DirectoryExists("src/dir"));
@@ skipping 19 matching lines @@
   FileSystemURL src_file(CreateFile("src"));
   FileSystemURL dest_file(CreateFile("dest"));
 
   EXPECT_EQ(base::File::FILE_OK, Truncate(dest_file, 6));
   EXPECT_EQ(base::File::FILE_OK,
             Copy(src_file, dest_file, FileSystemOperation::OPTION_NONE));
   EXPECT_EQ(0, GetFileSize("dest"));
 }
 
 }  // namespace content