Remove kint64max.

content/browser/fileapi/obfuscated_file_util_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 <stdint.h>
+
+#include <limits>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 32 matching lines @@
 using storage::kFileSystemTypePersistent;
 
 namespace content {
 
 namespace {
 
 bool FileExists(const base::FilePath& path) {
   return base::PathExists(path) && !base::DirectoryExists(path);
 }
 
-int64 GetSize(const base::FilePath& path) {
-  int64 size;
+int64_t GetSize(const base::FilePath& path) {
+  int64_t size;
   EXPECT_TRUE(base::GetFileSize(path, &size));
   return size;
 }
 
 // After a move, the dest exists and the source doesn't.
 // After a copy, both source and dest exist.
 struct CopyMoveTestCaseRecord {
   bool is_copy_not_move;
   const char source_path[64];
   const char dest_path[64];
@@ skipping 106 matching lines @@
     change_observers_ =
         storage::MockFileChangeObserver::CreateList(&change_observer_);
   }
 
   void TearDown() override {
     quota_manager_ = NULL;
     sandbox_file_system_.TearDown();
   }
 
   scoped_ptr<FileSystemOperationContext> LimitedContext(
-      int64 allowed_bytes_growth) {
+      int64_t allowed_bytes_growth) {
     scoped_ptr<FileSystemOperationContext> context(
         sandbox_file_system_.NewOperationContext());
     context->set_allowed_bytes_growth(allowed_bytes_growth);
     return context.Pass();
   }
 
   scoped_ptr<FileSystemOperationContext> UnlimitedContext() {
-    return LimitedContext(kint64max);
+    return LimitedContext(std::numeric_limits<int64_t>::max());
   }
 
   FileSystemOperationContext* NewContext(
       SandboxFileSystemTestHelper* file_system) {
     change_observer()->ResetCount();
     FileSystemOperationContext* context;
     if (file_system)
       context = file_system->NewOperationContext();
     else
       context = sandbox_file_system_.NewOperationContext();
@@ skipping 42 matching lines @@
   const GURL& origin() const {
     return origin_;
   }
 
   storage::FileSystemType type() const { return type_; }
 
   std::string type_string() const {
     return GetTypeString(type_);
   }
 
-  int64 ComputeTotalFileSize() {
+  int64_t ComputeTotalFileSize() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
         sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   void GetUsageFromQuotaManager() {
-    int64 quota = -1;
+    int64_t quota = -1;
     quota_status_ =
         AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(),
                                               origin(),
                                               sandbox_file_system_.type(),
                                               &usage_,
                                               &quota);
     EXPECT_EQ(storage::kQuotaStatusOk, quota_status_);
   }
 
   void RevokeUsageCache() {
     quota_manager_->ResetUsageTracker(sandbox_file_system_.storage_type());
     usage_cache()->Delete(sandbox_file_system_.GetUsageCachePath());
   }
 
-  int64 SizeByQuotaUtil() {
+  int64_t SizeByQuotaUtil() {
     return sandbox_file_system_.GetCachedOriginUsage();
   }
 
-  int64 SizeInUsageFile() {
+  int64_t SizeInUsageFile() {
     base::RunLoop().RunUntilIdle();
-    int64 usage = 0;
+    int64_t usage = 0;
     return usage_cache()->GetUsage(
         sandbox_file_system_.GetUsageCachePath(), &usage) ? usage : -1;
   }
 
   bool PathExists(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::File::Info file_info;
     base::FilePath platform_path;
     base::File::Error error = ofu()->GetFileInfo(
         context.get(), url, &file_info, &platform_path);
     return error == base::File::FILE_OK;
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
     return AsyncFileTestHelper::DirectoryExists(file_system_context(), url);
   }
 
-  int64 usage() const { return usage_; }
+  int64_t usage() const { return usage_; }
   storage::FileSystemUsageCache* usage_cache() {
     return sandbox_file_system_.usage_cache();
   }
 
   FileSystemURL CreateURLFromUTF8(const std::string& path) {
     return sandbox_file_system_.CreateURLFromUTF8(path);
   }
 
-  int64 PathCost(const FileSystemURL& url) {
+  int64_t PathCost(const FileSystemURL& url) {
     return ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   }
 
   FileSystemURL CreateURL(const base::FilePath& path) {
     return sandbox_file_system_.CreateURL(path);
   }
 
   void CheckFileAndCloseHandle(const FileSystemURL& url, base::File file) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::FilePath local_path;
@@ skipping 65 matching lines @@
       context.reset(NewContext(NULL));
       EXPECT_TRUE(DirectoryExists(
           FileSystemURLAppend(root_url, *iter)));
     }
   }
 
   class UsageVerifyHelper {
    public:
     UsageVerifyHelper(scoped_ptr<FileSystemOperationContext> context,
                       SandboxFileSystemTestHelper* file_system,
-                      int64 expected_usage)
+                      int64_t expected_usage)
         : context_(context.Pass()),
           sandbox_file_system_(file_system),
           expected_usage_(expected_usage) {}
 
     ~UsageVerifyHelper() {
       base::RunLoop().RunUntilIdle();
       Check();
     }
 
     FileSystemOperationContext* context() {
       return context_.get();
     }
 
    private:
     void Check() {
       ASSERT_EQ(expected_usage_,
                 sandbox_file_system_->GetCachedOriginUsage());
     }
 
     scoped_ptr<FileSystemOperationContext> context_;
     SandboxFileSystemTestHelper* sandbox_file_system_;
-    int64 expected_usage_;
+    int64_t expected_usage_;
   };
 
-  scoped_ptr<UsageVerifyHelper> AllowUsageIncrease(int64 requested_growth) {
-    int64 usage = sandbox_file_system_.GetCachedOriginUsage();
+  scoped_ptr<UsageVerifyHelper> AllowUsageIncrease(int64_t requested_growth) {
+    int64_t usage = sandbox_file_system_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth),
         &sandbox_file_system_, usage + requested_growth));
   }
 
-  scoped_ptr<UsageVerifyHelper> DisallowUsageIncrease(int64 requested_growth) {
-    int64 usage = sandbox_file_system_.GetCachedOriginUsage();
+  scoped_ptr<UsageVerifyHelper> DisallowUsageIncrease(
+      int64_t requested_growth) {
+    int64_t usage = sandbox_file_system_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth - 1), &sandbox_file_system_, usage));
   }
 
   void FillTestDirectory(
       const FileSystemURL& root_url,
       std::set<base::FilePath::StringType>* files,
       std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
     std::vector<storage::DirectoryEntry> entries;
@@ skipping 97 matching lines @@
     if (is_file)  // Directories in OFU don't support atime.
       EXPECT_EQ(file_info.last_accessed.ToTimeT(), last_access_time.ToTimeT());
   }
 
   void TestCopyInForeignFileHelper(bool overwrite) {
     base::ScopedTempDir source_dir;
     ASSERT_TRUE(source_dir.CreateUniqueTempDir());
     base::FilePath root_file_path = source_dir.path();
     base::FilePath src_file_path = root_file_path.AppendASCII("file_name");
     FileSystemURL dest_url = CreateURLFromUTF8("new file");
-    int64 src_file_length = 87;
+    int64_t src_file_length = 87;
 
     base::File file(src_file_path,
                     base::File::FLAG_CREATE | base::File::FLAG_WRITE);
     ASSERT_TRUE(file.IsValid());
     EXPECT_TRUE(file.created());
     ASSERT_TRUE(file.SetLength(src_file_length));
     file.Close();
 
     scoped_ptr<FileSystemOperationContext> context;
 
     if (overwrite) {
       context.reset(NewContext(NULL));
       bool created = false;
       EXPECT_EQ(base::File::FILE_OK,
                 ofu()->EnsureFileExists(context.get(), dest_url, &created));
       EXPECT_TRUE(created);
 
       // We must have observed one (and only one) create_file_count.
       EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count());
       EXPECT_TRUE(change_observer()->HasNoChange());
     }
 
-    const int64 path_cost =
+    const int64_t path_cost =
         ObfuscatedFileUtil::ComputeFilePathCost(dest_url.path());
     if (!overwrite) {
       // Verify that file creation requires sufficient quota for the path.
       context.reset(NewContext(NULL));
       context->set_allowed_bytes_growth(path_cost + src_file_length - 1);
       EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE,
                 ofu()->CopyInForeignFile(context.get(),
                                          src_file_path, dest_url));
     }
 
@@ skipping 191 matching lines @@
     EXPECT_FALSE(base::DirectoryExists(old_directory_db_path));
 
     // Check we see the same contents in the new origin directory.
     std::string origin_db_data;
     EXPECT_TRUE(base::PathExists(origin_directory.AppendASCII("dummy")));
     EXPECT_TRUE(base::ReadFileToString(
             origin_directory.AppendASCII("dummy"), &origin_db_data));
     EXPECT_EQ(kFakeDirectoryData, origin_db_data);
   }
 
-  int64 ComputeCurrentUsage() {
+  int64_t ComputeCurrentUsage() {
     return sandbox_file_system_.ComputeCurrentOriginUsage() -
         sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   FileSystemContext* file_system_context() {
     return sandbox_file_system_.file_system_context();
   }
 
   const base::FilePath& data_dir_path() const {
     return data_dir_.path();
   }
 
  protected:
   base::ScopedTempDir data_dir_;
   base::MessageLoopForIO message_loop_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<storage::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
   storage::FileSystemType type_;
   SandboxFileSystemTestHelper sandbox_file_system_;
   storage::QuotaStatusCode quota_status_;
-  int64 usage_;
+  int64_t usage_;
   storage::MockFileChangeObserver change_observer_;
   storage::ChangeObserverList change_observers_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
 };
 
 TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   FileSystemURL url = CreateURLFromUTF8("fake/file");
@@ skipping 441 matching lines @@
   url = CreateURLFromUTF8("file name");
   context->set_allowed_bytes_growth(5);
   bool created = false;
   EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE,
             ofu()->EnsureFileExists(context.get(), url, &created));
   EXPECT_FALSE(created);
   context->set_allowed_bytes_growth(1024);
   EXPECT_EQ(base::File::FILE_OK,
             ofu()->EnsureFileExists(context.get(), url, &created));
   EXPECT_TRUE(created);
-  int64 path_cost = ObfuscatedFileUtil::ComputeFilePathCost(url.path());
+  int64_t path_cost = ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth());
 
   context->set_allowed_bytes_growth(1024);
   bool exclusive = true;
   bool recursive = true;
   url = CreateURLFromUTF8("directory/to/use");
   std::vector<base::FilePath::StringType> components;
   url.path().GetComponents(&components);
   path_cost = 0;
   typedef std::vector<base::FilePath::StringType>::iterator iterator;
@@ skipping 45 matching lines @@
   context.reset(NewContext(NULL));
   is_copy_not_move = true;
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
             ofu()->CopyOrMoveFile(context.get(), source_url, dest_url,
                                   FileSystemOperation::OPTION_NONE,
                                   is_copy_not_move));
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) {
-  const int64 kSourceLength = 5;
-  const int64 kDestLength = 50;
+  const int64_t kSourceLength = 5;
+  const int64_t kDestLength = 50;
 
   for (size_t i = 0; i < arraysize(kCopyMoveTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "kCopyMoveTestCase " << i);
     const CopyMoveTestCaseRecord& test_case = kCopyMoveTestCases[i];
     SCOPED_TRACE(testing::Message() << "\t is_copy_not_move " <<
       test_case.is_copy_not_move);
     SCOPED_TRACE(testing::Message() << "\t source_path " <<
       test_case.source_path);
     SCOPED_TRACE(testing::Message() << "\t dest_path " <<
       test_case.dest_path);
@@ skipping 152 matching lines @@
   FileSystemURL dir_url = CreateURLFromUTF8("directory path");
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->CreateDirectory(context.get(), dir_url, exclusive,
                                    recursive));
 
   FileSystemURL dest_url = FileSystemURLAppend(
       dir_url, src_url.path().value());
 
   bool is_copy = false;
-  int64 allowed_bytes_growth = -1000;  // Over quota, this should still work.
+  int64_t allowed_bytes_growth = -1000;  // Over quota, this should still work.
   // Move, no rename, no overwrite.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(allowed_bytes_growth);
   EXPECT_EQ(base::File::FILE_OK,
             ofu()->CopyOrMoveFile(context.get(), src_url, dest_url,
                                   FileSystemOperation::OPTION_NONE, is_copy));
   EXPECT_EQ(allowed_bytes_growth, context->allowed_bytes_growth());
 
   // Move, no rename, with overwrite.
   context.reset(NewContext(NULL));
@@ skipping 130 matching lines @@
   std::set<GURL> diff;
   std::set_symmetric_difference(origins_expected.begin(),
       origins_expected.end(), origins_found.begin(), origins_found.end(),
       inserter(diff, diff.begin()));
   EXPECT_TRUE(diff.empty());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
-  int64 expected_quota = 0;
+  int64_t expected_quota = 0;
 
   for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
     SCOPED_TRACE(testing::Message() << "Creating kRegularTestCase " << i);
     const FileSystemTestCaseRecord& test_case =
         kRegularFileSystemTestCases[i];
     base::FilePath file_path(test_case.path);
     expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(file_path);
     if (test_case.is_directory) {
       bool exclusive = true;
       bool recursive = false;
@@ skipping 396 matching lines @@
 #else
 #define MAYBE_TestQuotaOnCopyFile TestQuotaOnCopyFile
 #endif
 TEST_F(ObfuscatedFileUtilTest, MAYBE_TestQuotaOnCopyFile) {
   FileSystemURL from_file(CreateURLFromUTF8("fromfile"));
   FileSystemURL obstacle_file(CreateURLFromUTF8("obstaclefile"));
   FileSystemURL to_file1(CreateURLFromUTF8("tofile1"));
   FileSystemURL to_file2(CreateURLFromUTF8("tofile2"));
   bool created;
 
-  int64 expected_total_file_size = 0;
+  int64_t expected_total_file_size = 0;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->EnsureFileExists(
                 AllowUsageIncrease(PathCost(from_file))->context(),
                 from_file, &created));
   ASSERT_TRUE(created);
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->EnsureFileExists(
                 AllowUsageIncrease(PathCost(obstacle_file))->context(),
                 obstacle_file, &created));
   ASSERT_TRUE(created);
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 from_file_size = 1020;
+  int64_t from_file_size = 1020;
   expected_total_file_size += from_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->Truncate(
                 AllowUsageIncrease(from_file_size)->context(),
                 from_file, from_file_size));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 obstacle_file_size = 1;
+  int64_t obstacle_file_size = 1;
   expected_total_file_size += obstacle_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->Truncate(
                 AllowUsageIncrease(obstacle_file_size)->context(),
                 obstacle_file, obstacle_file_size));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 to_file1_size = from_file_size;
+  int64_t to_file1_size = from_file_size;
   expected_total_file_size += to_file1_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->CopyOrMoveFile(
                 AllowUsageIncrease(
                     PathCost(to_file1) + to_file1_size)->context(),
                 from_file, to_file1,
                 FileSystemOperation::OPTION_NONE,
                 true /* copy */));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
   ASSERT_EQ(base::File::FILE_ERROR_NO_SPACE,
             ofu()->CopyOrMoveFile(
                 DisallowUsageIncrease(
                     PathCost(to_file2) + from_file_size)->context(),
                 from_file, to_file2, FileSystemOperation::OPTION_NONE,
                 true /* copy */));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 old_obstacle_file_size = obstacle_file_size;
+  int64_t old_obstacle_file_size = obstacle_file_size;
   obstacle_file_size = from_file_size;
   expected_total_file_size += obstacle_file_size - old_obstacle_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->CopyOrMoveFile(
                 AllowUsageIncrease(
                     obstacle_file_size - old_obstacle_file_size)->context(),
                 from_file, obstacle_file,
                 FileSystemOperation::OPTION_NONE,
                 true /* copy */));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 old_from_file_size = from_file_size;
+  int64_t old_from_file_size = from_file_size;
   from_file_size = old_from_file_size - 1;
   expected_total_file_size += from_file_size - old_from_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->Truncate(
                 AllowUsageIncrease(
                     from_file_size - old_from_file_size)->context(),
                 from_file, from_file_size));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
   // quota exceeded
@@ skipping 14 matching lines @@
     ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
   }
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnMoveFile) {
   FileSystemURL from_file(CreateURLFromUTF8("fromfile"));
   FileSystemURL obstacle_file(CreateURLFromUTF8("obstaclefile"));
   FileSystemURL to_file(CreateURLFromUTF8("tofile"));
   bool created;
 
-  int64 expected_total_file_size = 0;
+  int64_t expected_total_file_size = 0;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->EnsureFileExists(
                 AllowUsageIncrease(PathCost(from_file))->context(),
                 from_file, &created));
   ASSERT_TRUE(created);
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 from_file_size = 1020;
+  int64_t from_file_size = 1020;
   expected_total_file_size += from_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->Truncate(
                 AllowUsageIncrease(from_file_size)->context(),
                 from_file, from_file_size));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
   from_file_size = 0;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->CopyOrMoveFile(
@@ skipping 19 matching lines @@
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
   from_file_size = 1020;
   expected_total_file_size += from_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->Truncate(
                 AllowUsageIncrease(from_file_size)->context(),
                 from_file, from_file_size));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 obstacle_file_size = 1;
+  int64_t obstacle_file_size = 1;
   expected_total_file_size += obstacle_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->Truncate(
                 AllowUsageIncrease(1)->context(),
                 obstacle_file, obstacle_file_size));
   ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize());
 
-  int64 old_obstacle_file_size = obstacle_file_size;
+  int64_t old_obstacle_file_size = obstacle_file_size;
   obstacle_file_size = from_file_size;
   from_file_size = 0;
   expected_total_file_size -= old_obstacle_file_size;
   ASSERT_EQ(base::File::FILE_OK,
             ofu()->CopyOrMoveFile(
                 AllowUsageIncrease(
                     -old_obstacle_file_size - PathCost(from_file))->context(),
                 from_file, obstacle_file,
                 FileSystemOperation::OPTION_NONE,
                 false /* move */));
@@ skipping 321 matching lines @@
   ofu()->GetDirectoryForOriginAndType(
       origin2, GetTypeString(kFileSystemTypeTemporary), false, &error);
   ASSERT_EQ(base::File::FILE_OK, error);
   error = base::File::FILE_ERROR_FAILED;
   ofu()->GetDirectoryForOriginAndType(
       origin2, GetTypeString(kFileSystemTypePersistent), false, &error);
   ASSERT_EQ(base::File::FILE_OK, error);
 }
 
 }  // namespace content