Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk_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 "chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
-const int64 kSyncRootTrackerID = 1;
-const int64 kAppRootTrackerID = 2;
-const int64 kFileTrackerID = 3;
-const int64 kPlaceholderTrackerID = 4;
+const int64_t kSyncRootTrackerID = 1;
+const int64_t kAppRootTrackerID = 2;
+const int64_t kFileTrackerID = 3;
+const int64_t kPlaceholderTrackerID = 4;
 
 }  // namespace
 
 class MetadataDatabaseIndexOnDiskTest : public testing::Test {
  public:
   ~MetadataDatabaseIndexOnDiskTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(database_dir_.CreateUniqueTempDir());
     in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
@@ skipping 106 matching lines @@
 
   FileMetadata metadata;
   EXPECT_FALSE(index()->GetFileMetadata(std::string(), nullptr));
   ASSERT_TRUE(index()->GetFileMetadata("file_id", &metadata));
   EXPECT_EQ("file_id", metadata.file_id());
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest, SetEntryTest) {
   CreateTestDatabase(false, nullptr);
 
-  const int64 tracker_id = 10;
+  const int64_t tracker_id = 10;
   scoped_ptr<FileMetadata> metadata =
       test_util::CreateFileMetadata("test_file_id", "test_title", "test_md5");
   FileTracker root_tracker;
   EXPECT_TRUE(index()->GetFileTracker(kSyncRootTrackerID, &root_tracker));
   scoped_ptr<FileTracker> tracker =
       test_util::CreateTracker(*metadata, tracker_id, &root_tracker);
 
   index()->StoreFileMetadata(metadata.Pass());
   index()->StoreFileTracker(tracker.Pass());
 
@@ skipping 55 matching lines @@
 
   EXPECT_TRUE(index_on_disk->GetFileTracker(kSyncRootTrackerID, nullptr));
   EXPECT_TRUE(index_on_disk->GetFileTracker(kAppRootTrackerID, nullptr));
   EXPECT_TRUE(index_on_disk->GetFileTracker(kFileTrackerID, nullptr));
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest, SyncRootInvalidation) {
   CreateTestDatabase(true, nullptr);
   EXPECT_NE(kInvalidTrackerID, index()->GetAppRootTracker("app_id"));
 
-  const int64 kNewSyncRootTrackerID = 10;
+  const int64_t kNewSyncRootTrackerID = 10;
   scoped_ptr<FileMetadata> new_sync_root_metadata =
       test_util::CreateFolderMetadata("new_sync_root_folder_id",
                                       kSyncRootFolderTitle);
   scoped_ptr<FileTracker> new_sync_root_tracker =
       test_util::CreateTracker(*new_sync_root_metadata, kNewSyncRootTrackerID,
                                nullptr);
 
   // Override SyncRoot with a new one.
   index()->StoreFileMetadata(new_sync_root_metadata.Pass());
   index()->StoreFileTracker(new_sync_root_tracker.Pass());
@@ skipping 29 matching lines @@
   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file");
   EXPECT_EQ(1U, tracker_ids.size());
   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
   EXPECT_EQ(1U, index()->CountDirtyTracker());
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest, BuildAndDeleteIndexTest) {
   CreateTestDatabase(false, nullptr);
-  int64 answer = index()->BuildTrackerIndexes();
+  int64_t answer = index()->BuildTrackerIndexes();
   WriteToDB();
   ASSERT_EQ(16, answer);
   EXPECT_EQ(answer, index()->DeleteTrackerIndexes());
   WriteToDB();
   EXPECT_EQ(answer, index()->BuildTrackerIndexes());
   WriteToDB();
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest, AllEntriesTest) {
   CreateTestDatabase(true, nullptr);
 
   EXPECT_EQ(3U, index()->CountFileMetadata());
   std::vector<std::string> file_ids(index()->GetAllMetadataIDs());
   ASSERT_EQ(3U, file_ids.size());
   std::sort(file_ids.begin(), file_ids.end());
   EXPECT_EQ("app_root_folder_id", file_ids[0]);
   EXPECT_EQ("file_id", file_ids[1]);
   EXPECT_EQ("sync_root_folder_id", file_ids[2]);
 
   EXPECT_EQ(4U, index()->CountFileTracker());
-  std::vector<int64> tracker_ids = index()->GetAllTrackerIDs();
+  std::vector<int64_t> tracker_ids = index()->GetAllTrackerIDs();
   ASSERT_EQ(4U, tracker_ids.size());
   std::sort(tracker_ids.begin(), tracker_ids.end());
   EXPECT_EQ(kSyncRootTrackerID, tracker_ids[0]);
   EXPECT_EQ(kAppRootTrackerID, tracker_ids[1]);
   EXPECT_EQ(kFileTrackerID, tracker_ids[2]);
   EXPECT_EQ(kPlaceholderTrackerID, tracker_ids[3]);
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest, IndexAppRootIDByAppIDTest) {
   CreateTestDatabase(true, nullptr);
 
   std::vector<std::string> app_ids = index()->GetRegisteredAppIDs();
   ASSERT_EQ(1U, app_ids.size());
   EXPECT_EQ("app_id", app_ids[0]);
 
   EXPECT_EQ(kInvalidTrackerID, index()->GetAppRootTracker(""));
   EXPECT_EQ(kAppRootTrackerID, index()->GetAppRootTracker("app_id"));
 
-  const int64 kAppRootTrackerID2 = 12;
+  const int64_t kAppRootTrackerID2 = 12;
   FileTracker sync_root_tracker;
   index()->GetFileTracker(kSyncRootTrackerID, &sync_root_tracker);
   scoped_ptr<FileMetadata> app_root_metadata =
       test_util::CreateFolderMetadata("app_root_folder_id_2", "app_title_2");
 
   // Testing AddToAppIDIndex
   scoped_ptr<FileTracker> app_root_tracker =
       test_util::CreateTracker(*app_root_metadata, kAppRootTrackerID2,
                                &sync_root_tracker);
   app_root_tracker->set_app_id("app_id_2");
@@ skipping 42 matching lines @@
   FileTracker app_root_tracker;
   EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root_tracker));
   FileMetadata metadata;
   EXPECT_TRUE(index()->GetFileMetadata("file_id", &metadata));
 
   // Testing GetFileTrackerIDsByFileID
   TrackerIDSet tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
   EXPECT_EQ(1U, tracker_ids.size());
   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
 
-  const int64 tracker_id = 21;
+  const int64_t tracker_id = 21;
   // Testing AddToFileIDIndexes
   scoped_ptr<FileTracker> file_tracker =
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 
   index()->StoreFileTracker(file_tracker.Pass());
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByFileID("file_id");
   EXPECT_EQ(2U, tracker_ids.size());
   EXPECT_EQ(tracker_id, tracker_ids.active_tracker());
 
@@ skipping 48 matching lines @@
   // Testing GetFileTrackerIDsByFileID
   TrackerIDSet tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file");
   EXPECT_EQ(1U, tracker_ids.size());
   EXPECT_EQ(kFileTrackerID, tracker_ids.active_tracker());
 
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file2");
   EXPECT_TRUE(tracker_ids.empty());
 
-  const int64 tracker_id = 72;
+  const int64_t tracker_id = 72;
   // Testing AddToFileIDIndexes
   scoped_ptr<FileTracker> file_tracker =
       test_util::CreateTracker(metadata, tracker_id, &app_root_tracker);
 
   index()->StoreFileTracker(file_tracker.Pass());
   WriteToDB();
   tracker_ids = index()->GetFileTrackerIDsByParentAndTitle(
       kAppRootTrackerID, "file");
   EXPECT_EQ(2U, tracker_ids.size());
   EXPECT_EQ(tracker_id, tracker_ids.active_tracker());
@@ skipping 42 matching lines @@
 
   multi_backing = index()->PickMultiBackingFilePath();
   EXPECT_EQ(kInvalidTrackerID, multi_backing.parent_id);
   EXPECT_TRUE(multi_backing.title.empty()) << multi_backing.title;
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest,
        TrackerIDSetByParentIDAndTitleTest_EmptyTitle) {
   CreateTestDatabase(true, nullptr);
 
-  const int64 kFolderTrackerID = 23;
-  const int64 kNewFileTrackerID = 42;
+  const int64_t kFolderTrackerID = 23;
+  const int64_t kNewFileTrackerID = 42;
   {
     FileTracker app_root_tracker;
     EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root_tracker));
     scoped_ptr<FileMetadata> folder_metadata =
         test_util::CreateFolderMetadata("folder_id", "folder_name");
     scoped_ptr<FileTracker> folder_tracker =
         test_util::CreateTracker(*folder_metadata, kFolderTrackerID,
                                  &app_root_tracker);
     index()->StoreFileMetadata(folder_metadata.Pass());
     index()->StoreFileTracker(folder_tracker.Pass());
@@ skipping 38 matching lines @@
   multi_backing = index()->PickMultiBackingFilePath();
   EXPECT_EQ(kInvalidTrackerID, multi_backing.parent_id);
 }
 
 TEST_F(MetadataDatabaseIndexOnDiskTest, TrackerIDSetDetailsTest) {
   CreateTestDatabase(true, nullptr);
 
   FileTracker app_root;
   EXPECT_TRUE(index()->GetFileTracker(kAppRootTrackerID, &app_root));
 
-  const int64 kFileTrackerID2 = 123;
-  const int64 kFileTrackerID3 = 124;
+  const int64_t kFileTrackerID2 = 123;
+  const int64_t kFileTrackerID3 = 124;
   scoped_ptr<FileMetadata> file_metadata =
       test_util::CreateFileMetadata("file_id2", "file_2", "file_md5_2");
   scoped_ptr<FileTracker> file_tracker =
       test_util::CreateTracker(*file_metadata, kFileTrackerID2, &app_root);
   file_tracker->set_active(false);
   scoped_ptr<FileTracker> file_tracker2 =
       test_util::CreateTracker(*file_metadata, kFileTrackerID3, &app_root);
   file_tracker2->set_active(false);
 
   // Add 2 trackers related to one file metadata.
@@ skipping 22 matching lines @@
 
   // Testing public methods
   EXPECT_EQ(1U, index()->CountDirtyTracker());
   EXPECT_FALSE(index()->HasDemotedDirtyTracker());
   EXPECT_EQ(kPlaceholderTrackerID, index()->PickDirtyTracker());
   index()->DemoteDirtyTracker(kPlaceholderTrackerID);
   WriteToDB();
   EXPECT_TRUE(index()->HasDemotedDirtyTracker());
   EXPECT_EQ(0U, index()->CountDirtyTracker());
 
-  const int64 tracker_id = 13;
+  const int64_t tracker_id = 13;
   scoped_ptr<FileTracker> app_root_tracker(new FileTracker);
   index()->GetFileTracker(kAppRootTrackerID, app_root_tracker.get());
 
   // Testing AddDirtyTrackerIndexes
   scoped_ptr<FileTracker> tracker =
       test_util::CreatePlaceholderTracker("placeholder",
                                           tracker_id,
                                           app_root_tracker.get());
   index()->StoreFileTracker(tracker.Pass());
   WriteToDB();
@@ skipping 25 matching lines @@
   EXPECT_EQ(kInvalidTrackerID, index()->PickDirtyTracker());
 
   // Demoted trackers
   EXPECT_TRUE(index()->HasDemotedDirtyTracker());
   EXPECT_TRUE(index()->PromoteDemotedDirtyTrackers());
   EXPECT_FALSE(index()->HasDemotedDirtyTracker());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system