Switch to standard integer types in content/browser/.

content/browser/fileapi/copy_or_move_operation_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 <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <queue>
 
-#include "base/basictypes.h"
 #include "base/bind.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/stl_util.h"
 #include "base/thread_task_runner_handle.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"
 #include "content/public/test/test_file_system_backend.h"
 #include "content/public/test/test_file_system_context.h"
 #include "content/test/fileapi_test_file_set.h"
@@ skipping 82 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(TestValidator);
   };
 };
 
 // Records CopyProgressCallback invocations.
 struct ProgressRecord {
   storage::FileSystemOperation::CopyProgressType type;
   FileSystemURL source_url;
   FileSystemURL dest_url;
-  int64 size;
+  int64_t size;
 };
 
 void RecordProgressCallback(std::vector<ProgressRecord>* records,
                             storage::FileSystemOperation::CopyProgressType type,
                             const FileSystemURL& source_url,
                             const FileSystemURL& dest_url,
-                            int64 size) {
+                            int64_t size) {
   ProgressRecord record;
   record.type = type;
   record.source_url = source_url;
   record.dest_url = dest_url;
   record.size = size;
   records->push_back(record);
 }
 
-void RecordFileProgressCallback(std::vector<int64>* records,
-                                int64 progress) {
+void RecordFileProgressCallback(std::vector<int64_t>* records,
+                                int64_t progress) {
   records->push_back(progress);
 }
 
 void AssignAndQuit(base::RunLoop* run_loop,
                    base::File::Error* result_out,
                    base::File::Error result) {
   *result_out = result;
   run_loop->Quit();
 }
 
@@ skipping 87 matching lines @@
     quota_manager_->SetQuota(
         origin_,
         storage::FileSystemTypeToQuotaStorageType(src_type_),
         1024 * 1024);
     quota_manager_->SetQuota(
         origin_,
         storage::FileSystemTypeToQuotaStorageType(dest_type_),
         1024 * 1024);
   }
 
-  int64 GetSourceUsage() {
-    int64 usage = 0;
+  int64_t GetSourceUsage() {
+    int64_t usage = 0;
     GetUsageAndQuota(src_type_, &usage, NULL);
     return usage;
   }
 
-  int64 GetDestUsage() {
-    int64 usage = 0;
+  int64_t GetDestUsage() {
+    int64_t usage = 0;
     GetUsageAndQuota(dest_type_, &usage, NULL);
     return usage;
   }
 
   FileSystemURL SourceURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin_, src_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
   FileSystemURL DestURL(const std::string& path) {
@@ skipping 99 matching lines @@
 
   base::File::Error CreateFile(const FileSystemURL& url, size_t size) {
     base::File::Error result =
         AsyncFileTestHelper::CreateFile(file_system_context_.get(), url);
     if (result != base::File::FILE_OK)
       return result;
     return AsyncFileTestHelper::TruncateFile(
         file_system_context_.get(), url, size);
   }
 
-  bool FileExists(const FileSystemURL& url, int64 expected_size) {
+  bool FileExists(const FileSystemURL& url, int64_t expected_size) {
     return AsyncFileTestHelper::FileExists(
         file_system_context_.get(), url, expected_size);
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
     return AsyncFileTestHelper::DirectoryExists(file_system_context_.get(),
                                                 url);
   }
 
  private:
   void GetUsageAndQuota(storage::FileSystemType type,
-                        int64* usage,
-                        int64* quota) {
+                        int64_t* usage,
+                        int64_t* quota) {
     storage::QuotaStatusCode status = AsyncFileTestHelper::GetUsageAndQuota(
         quota_manager_.get(), origin_, type, usage, quota);
     ASSERT_EQ(storage::kQuotaStatusOk, status);
   }
 
  private:
   base::ScopedTempDir base_;
 
   const GURL origin_;
   const storage::FileSystemType src_type_;
   const storage::FileSystemType dest_type_;
 
   base::MessageLoopForIO message_loop_;
   scoped_refptr<storage::FileSystemContext> file_system_context_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<MockQuotaManager> quota_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(CopyOrMoveOperationTestHelper);
 };
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
-  int64 src_initial_usage = helper.GetSourceUsage();
-  int64 dest_initial_usage = helper.GetDestUsage();
+  int64_t src_initial_usage = helper.GetSourceUsage();
+  int64_t dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source file.
   ASSERT_EQ(base::File::FILE_OK, helper.CreateFile(src, 10));
-  int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
+  int64_t src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
   ASSERT_EQ(base::File::FILE_OK, helper.Copy(src, dest));
 
   // Verify.
   ASSERT_TRUE(helper.FileExists(src, 10));
   ASSERT_TRUE(helper.FileExists(dest, 10));
 
-  int64 src_new_usage = helper.GetSourceUsage();
+  int64_t src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
-  int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
+  int64_t dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
-  int64 src_initial_usage = helper.GetSourceUsage();
-  int64 dest_initial_usage = helper.GetDestUsage();
+  int64_t src_initial_usage = helper.GetSourceUsage();
+  int64_t dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source file.
   ASSERT_EQ(base::File::FILE_OK, helper.CreateFile(src, 10));
-  int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
+  int64_t src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
   ASSERT_EQ(base::File::FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.FileExists(src, AsyncFileTestHelper::kDontCheckSize));
   ASSERT_TRUE(helper.FileExists(dest, 10));
 
-  int64 src_new_usage = helper.GetSourceUsage();
+  int64_t src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
-  int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
+  int64_t dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
-  int64 src_initial_usage = helper.GetSourceUsage();
-  int64 dest_initial_usage = helper.GetDestUsage();
+  int64_t src_initial_usage = helper.GetSourceUsage();
+  int64_t dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
-  int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
+  int64_t src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
   ASSERT_EQ(base::File::FILE_OK, helper.Copy(src, dest));
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
-  int64 src_new_usage = helper.GetSourceUsage();
+  int64_t src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
-  int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
+  int64_t dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
-  int64 src_initial_usage = helper.GetSourceUsage();
-  int64 dest_initial_usage = helper.GetDestUsage();
+  int64_t src_initial_usage = helper.GetSourceUsage();
+  int64_t dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
-  int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
+  int64_t src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
   ASSERT_EQ(base::File::FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
-  int64 src_new_usage = helper.GetSourceUsage();
+  int64_t src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
-  int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
+  int64_t dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopyDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
-  int64 src_initial_usage = helper.GetSourceUsage();
-  int64 dest_initial_usage = helper.GetDestUsage();
+  int64_t src_initial_usage = helper.GetSourceUsage();
+  int64_t dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
   ASSERT_EQ(base::File::FILE_OK,
             helper.SetUpTestCaseFiles(src,
                                       kRegularFileSystemTestCases,
                                       kRegularFileSystemTestCaseSize));
-  int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
+  int64_t src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
   ASSERT_EQ(base::File::FILE_OK,
             helper.CopyWithProgress(
                 src, dest,
                 AsyncFileTestHelper::CopyProgressCallback()));
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   helper.VerifyTestCaseFiles(dest,
                              kRegularFileSystemTestCases,
                              kRegularFileSystemTestCaseSize);
 
-  int64 src_new_usage = helper.GetSourceUsage();
+  int64_t src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
-  int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
+  int64_t dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
-  int64 src_initial_usage = helper.GetSourceUsage();
-  int64 dest_initial_usage = helper.GetDestUsage();
+  int64_t src_initial_usage = helper.GetSourceUsage();
+  int64_t dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::File::FILE_OK, helper.CreateDirectory(src));
   ASSERT_EQ(base::File::FILE_OK,
             helper.SetUpTestCaseFiles(src,
                                       kRegularFileSystemTestCases,
                                       kRegularFileSystemTestCaseSize));
-  int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
+  int64_t src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
   ASSERT_EQ(base::File::FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   helper.VerifyTestCaseFiles(dest,
                              kRegularFileSystemTestCases,
                              kRegularFileSystemTestCaseSize);
 
-  int64 src_new_usage = helper.GetSourceUsage();
+  int64_t src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
-  int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
+  int64_t dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest,
      MoveDirectoryFailPostWriteValidation) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
                                        storage::kFileSystemTypeTemporary,
                                        storage::kFileSystemTypeTest);
   helper.SetUp();
 
@@ skipping 93 matching lines @@
               records[begin_index].type);
     EXPECT_FALSE(records[begin_index].dest_url.is_valid());
     EXPECT_EQ(FileSystemOperation::END_COPY_ENTRY, records[end_index].type);
     EXPECT_EQ(dest_url, records[end_index].dest_url);
 
     if (test_case.is_directory) {
       // For directory copy, the progress shouldn't be interlaced.
       EXPECT_EQ(begin_index + 1, end_index);
     } else {
       // PROGRESS event's size should be assending order.
-      int64 current_size = 0;
+      int64_t current_size = 0;
       for (size_t j = begin_index + 1; j < end_index; ++j) {
         if (records[j].source_url == src_url) {
           EXPECT_EQ(FileSystemOperation::PROGRESS, records[j].type);
           EXPECT_FALSE(records[j].dest_url.is_valid());
           EXPECT_GE(records[j].size, current_size);
           current_size = records[j].size;
         }
       }
     }
   }
@@ skipping 17 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       file_thread.task_runner();
 
   scoped_ptr<storage::FileStreamReader> reader(
       storage::FileStreamReader::CreateForLocalFile(
           task_runner.get(), source_path, 0, base::Time()));
 
   scoped_ptr<FileStreamWriter> writer(FileStreamWriter::CreateForLocalFile(
       task_runner.get(), dest_path, 0, FileStreamWriter::CREATE_NEW_FILE));
 
-  std::vector<int64> progress;
+  std::vector<int64_t> progress;
   CopyOrMoveOperationDelegate::StreamCopyHelper helper(
       reader.Pass(), writer.Pass(),
       storage::FlushPolicy::NO_FLUSH_ON_COMPLETION,
       10,  // buffer size
       base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)),
       base::TimeDelta());  // For testing, we need all the progress.
 
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
@@ skipping 35 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       file_thread.task_runner();
 
   scoped_ptr<storage::FileStreamReader> reader(
       storage::FileStreamReader::CreateForLocalFile(
           task_runner.get(), source_path, 0, base::Time()));
 
   scoped_ptr<FileStreamWriter> writer(FileStreamWriter::CreateForLocalFile(
       task_runner.get(), dest_path, 0, FileStreamWriter::CREATE_NEW_FILE));
 
-  std::vector<int64> progress;
+  std::vector<int64_t> progress;
   CopyOrMoveOperationDelegate::StreamCopyHelper helper(
       reader.Pass(), writer.Pass(),
       storage::FlushPolicy::NO_FLUSH_ON_COMPLETION,
       10,  // buffer size
       base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)),
       base::TimeDelta());  // For testing, we need all the progress.
 
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
@@ skipping 30 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       file_thread.task_runner();
 
   scoped_ptr<storage::FileStreamReader> reader(
       storage::FileStreamReader::CreateForLocalFile(
           task_runner.get(), source_path, 0, base::Time()));
 
   scoped_ptr<FileStreamWriter> writer(FileStreamWriter::CreateForLocalFile(
       task_runner.get(), dest_path, 0, FileStreamWriter::CREATE_NEW_FILE));
 
-  std::vector<int64> progress;
+  std::vector<int64_t> progress;
   CopyOrMoveOperationDelegate::StreamCopyHelper helper(
       reader.Pass(), writer.Pass(),
       storage::FlushPolicy::NO_FLUSH_ON_COMPLETION,
       10,  // buffer size
       base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)),
       base::TimeDelta());  // For testing, we need all the progress.
 
   // Call Cancel() later.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CopyOrMoveOperationDelegate::StreamCopyHelper::Cancel,
                  base::Unretained(&helper)));
 
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
   run_loop.Run();
 
   EXPECT_EQ(base::File::FILE_ERROR_ABORT, error);
 }
 
 }  // namespace content