Switch to standard integer types in components/, part 1 of 4.

components/drive/resource_metadata_storage_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 "components/drive/resource_metadata_storage.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/drive_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
@@ skipping 42 matching lines @@
         ResourceMetadataStorage::GetChildEntryKey(parent_id, child_base_name));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
   scoped_ptr<ResourceMetadataStorage,
              test_util::DestroyHelperForTests> storage_;
 };
 
 TEST_F(ResourceMetadataStorageTest, LargestChangestamp) {
-  const int64 kLargestChangestamp = 1234567890;
+  const int64_t kLargestChangestamp = 1234567890;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->SetLargestChangestamp(kLargestChangestamp));
-  int64 value = 0;
+  int64_t value = 0;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetLargestChangestamp(&value));
   EXPECT_EQ(kLargestChangestamp, value);
 }
 
 TEST_F(ResourceMetadataStorageTest, PutEntry) {
   const std::string key1 = "abcdefg";
   const std::string key2 = "abcd";
   const std::string key3 = "efgh";
   const std::string name2 = "ABCD";
   const std::string name3 = "EFGH";
@@ skipping 190 matching lines @@
   EXPECT_EQ(parent_id1, result.parent_local_id());
   EXPECT_EQ(child_name1, result.base_name());
 
   std::string child_id;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetChild(parent_id1, child_name1, &child_id));
   EXPECT_EQ(child_id1, child_id);
 }
 
 TEST_F(ResourceMetadataStorageTest, IncompatibleDB_M29) {
-  const int64 kLargestChangestamp = 1234567890;
+  const int64_t kLargestChangestamp = 1234567890;
   const std::string title = "title";
 
   // Construct M29 version DB.
   SetDBVersion(6);
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->SetLargestChangestamp(kLargestChangestamp));
 
   leveldb::WriteBatch batch;
 
   // Put a file entry and its cache entry.
@@ skipping 16 matching lines @@
   storage_.reset(new ResourceMetadataStorage(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Resource-ID-to-local-ID mapping is added.
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetIdByResourceId("abcd", &id));  // "file:" is dropped.
 
   // Data is erased, except cache entries.
-  int64 largest_changestamp = 0;
+  int64_t largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(0, largest_changestamp);
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.title().empty());
   EXPECT_TRUE(entry.file_specific_info().has_cache_state());
 }
 
 TEST_F(ResourceMetadataStorageTest, IncompatibleDB_M32) {
-  const int64 kLargestChangestamp = 1234567890;
+  const int64_t kLargestChangestamp = 1234567890;
   const std::string title = "title";
   const std::string resource_id = "abcd";
   const std::string local_id = "local-abcd";
 
   // Construct M32 version DB.
   SetDBVersion(11);
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->SetLargestChangestamp(kLargestChangestamp));
 
   leveldb::WriteBatch batch;
@@ skipping 19 matching lines @@
   storage_.reset();
   EXPECT_TRUE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Data is erased, except cache and id mapping entries.
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetIdByResourceId(resource_id, &id));
   EXPECT_EQ(local_id, id);
-  int64 largest_changestamp = 0;
+  int64_t largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(0, largest_changestamp);
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetEntry(id, &entry));
   EXPECT_TRUE(entry.title().empty());
   EXPECT_TRUE(entry.file_specific_info().has_cache_state());
 }
 
 TEST_F(ResourceMetadataStorageTest, IncompatibleDB_M33) {
-  const int64 kLargestChangestamp = 1234567890;
+  const int64_t kLargestChangestamp = 1234567890;
   const std::string title = "title";
   const std::string resource_id = "abcd";
   const std::string local_id = "local-abcd";
   const std::string md5 = "md5";
   const std::string resource_id2 = "efgh";
   const std::string local_id2 = "local-efgh";
   const std::string md5_2 = "md5_2";
 
   // Construct M33 version DB.
   SetDBVersion(12);
@@ skipping 27 matching lines @@
   EXPECT_TRUE(resource_map()->Write(leveldb::WriteOptions(), &batch).ok());
 
   // Upgrade and reopen.
   storage_.reset();
   EXPECT_TRUE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // No data is lost.
-  int64 largest_changestamp = 0;
+  int64_t largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(kLargestChangestamp, largest_changestamp);
 
   std::string id;
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetIdByResourceId(resource_id, &id));
   EXPECT_EQ(local_id, id);
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetEntry(id, &entry));
   EXPECT_EQ(title, entry.title());
   EXPECT_EQ(md5, entry.file_specific_info().cache_state().md5());
 
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetIdByResourceId(resource_id2, &id));
   EXPECT_EQ(local_id2, id);
   EXPECT_EQ(FILE_ERROR_OK, storage_->GetEntry(id, &entry));
   EXPECT_EQ(md5_2, entry.file_specific_info().cache_state().md5());
 }
 
 TEST_F(ResourceMetadataStorageTest, IncompatibleDB_Unknown) {
-  const int64 kLargestChangestamp = 1234567890;
+  const int64_t kLargestChangestamp = 1234567890;
   const std::string key1 = "abcd";
 
   // Put some data.
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->SetLargestChangestamp(kLargestChangestamp));
   ResourceEntry entry;
   entry.set_local_id(key1);
   EXPECT_EQ(FILE_ERROR_OK, storage_->PutEntry(entry));
 
   // Set newer version, upgrade and reopen DB.
   SetDBVersion(ResourceMetadataStorage::kDBVersion + 1);
   storage_.reset();
   EXPECT_FALSE(ResourceMetadataStorage::UpgradeOldDB(temp_dir_.path()));
   storage_.reset(new ResourceMetadataStorage(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get()));
   ASSERT_TRUE(storage_->Initialize());
 
   // Data is erased because of the incompatible version.
-  int64 largest_changestamp = 0;
+  int64_t largest_changestamp = 0;
   EXPECT_EQ(FILE_ERROR_OK,
             storage_->GetLargestChangestamp(&largest_changestamp));
   EXPECT_EQ(0, largest_changestamp);
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, storage_->GetEntry(key1, &entry));
 }
 
 TEST_F(ResourceMetadataStorageTest, DeleteUnusedIDEntries) {
   leveldb::WriteBatch batch;
 
   // Put an ID entry with a corresponding ResourceEntry.
@@ skipping 143 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key3));
   EXPECT_TRUE(CheckValidity());
 
   // Remove key1.
   EXPECT_EQ(FILE_ERROR_OK, storage_->RemoveEntry(key1));
   EXPECT_TRUE(CheckValidity());
 }
 
 }  // namespace internal
 }  // namespace drive