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

chrome/browser/sync_file_system/drive_backend/metadata_database.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 "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
@@ skipping 80 matching lines @@
 
   details->set_md5(file_resource.md5_checksum());
   details->set_etag(file_resource.etag());
   details->set_creation_time(file_resource.created_date().ToInternalValue());
   details->set_modification_time(
       file_resource.modified_date().ToInternalValue());
   details->set_missing(file_resource.labels().is_trashed());
 }
 
 scoped_ptr<FileMetadata> CreateFileMetadataFromFileResource(
-    int64 change_id,
+    int64_t change_id,
     const google_apis::FileResource& resource) {
   scoped_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(resource.file_id());
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change_id);
 
   if (resource.labels().is_trashed()) {
     details->set_missing(true);
     return file.Pass();
@@ skipping 13 matching lines @@
 
   if (change.is_deleted()) {
     details->set_missing(true);
     return file.Pass();
   }
 
   PopulateFileDetailsByFileResource(*change.file(), details);
   return file.Pass();
 }
 
-scoped_ptr<FileMetadata> CreateDeletedFileMetadata(
-    int64 change_id,
-    const std::string& file_id) {
+scoped_ptr<FileMetadata> CreateDeletedFileMetadata(int64_t change_id,
+                                                   const std::string& file_id) {
   scoped_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(file_id);
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change_id);
   details->set_missing(true);
   return file.Pass();
 }
 
 scoped_ptr<FileTracker> CreateSyncRootTracker(
-    int64 tracker_id,
+    int64_t tracker_id,
     const FileMetadata& sync_root_metadata) {
   scoped_ptr<FileTracker> sync_root_tracker(new FileTracker);
   sync_root_tracker->set_tracker_id(tracker_id);
   sync_root_tracker->set_file_id(sync_root_metadata.file_id());
   sync_root_tracker->set_parent_tracker_id(0);
   sync_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   sync_root_tracker->set_dirty(false);
   sync_root_tracker->set_active(true);
   sync_root_tracker->set_needs_folder_listing(false);
   *sync_root_tracker->mutable_synced_details() = sync_root_metadata.details();
   return sync_root_tracker.Pass();
 }
 
 scoped_ptr<FileTracker> CreateInitialAppRootTracker(
-    int64 tracker_id,
-    int64 parent_tracker_id,
+    int64_t tracker_id,
+    int64_t parent_tracker_id,
     const FileMetadata& app_root_metadata) {
   scoped_ptr<FileTracker> app_root_tracker(new FileTracker);
   app_root_tracker->set_tracker_id(tracker_id);
   app_root_tracker->set_parent_tracker_id(parent_tracker_id);
   app_root_tracker->set_file_id(app_root_metadata.file_id());
   app_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   app_root_tracker->set_dirty(false);
   app_root_tracker->set_active(false);
   app_root_tracker->set_needs_folder_listing(false);
   *app_root_tracker->mutable_synced_details() = app_root_metadata.details();
@@ skipping 46 matching lines @@
   *created = IsDatabaseEmpty(db_out->get());
   return status;
 }
 
 SyncStatusCode MigrateDatabaseIfNeeded(LevelDBWrapper* db) {
   // See metadata_database_index.cc for the database schema.
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db);
   std::string value;
   leveldb::Status status = db->Get(kDatabaseVersionKey, &value);
-  int64 version = 0;
+  int64_t version = 0;
   if (status.ok()) {
     if (!base::StringToInt64(value, &version))
       return SYNC_DATABASE_ERROR_FAILED;
   } else {
     if (!status.IsNotFound())
       return SYNC_DATABASE_ERROR_FAILED;
   }
 
   switch (version) {
     case 0:
@@ skipping 31 matching lines @@
        itr != trackers.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(*itr, tracker.get());
     if (tracker->dirty())
       continue;
     tracker->set_dirty(true);
     index->StoreFileTracker(tracker.Pass());
   }
 }
 
-void MarkTrackersDirtyByPath(int64 parent_tracker_id,
+void MarkTrackersDirtyByPath(int64_t parent_tracker_id,
                              const std::string& title,
                              MetadataDatabaseIndexInterface* index) {
   if (parent_tracker_id == kInvalidTrackerID || title.empty())
     return;
   MarkTrackerSetDirty(
       index->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title),
       index);
 }
 
 void MarkTrackersDirtyByFileID(const std::string& file_id,
                                MetadataDatabaseIndexInterface* index) {
   MarkTrackerSetDirty(index->GetFileTrackerIDsByFileID(file_id), index);
 }
 
-void MarkTrackersDirtyRecursively(int64 root_tracker_id,
+void MarkTrackersDirtyRecursively(int64_t root_tracker_id,
                                   MetadataDatabaseIndexInterface* index) {
-  std::vector<int64> stack;
+  std::vector<int64_t> stack;
   stack.push_back(root_tracker_id);
   while (!stack.empty()) {
-    int64 tracker_id = stack.back();
+    int64_t tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     scoped_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(tracker_id, tracker.get());
     tracker->set_dirty(true);
 
     index->StoreFileTracker(tracker.Pass());
   }
 }
 
-void RemoveAllDescendantTrackers(int64 root_tracker_id,
+void RemoveAllDescendantTrackers(int64_t root_tracker_id,
                                  MetadataDatabaseIndexInterface* index) {
-  std::vector<int64> pending_trackers;
+  std::vector<int64_t> pending_trackers;
   AppendContents(index->GetFileTrackerIDsByParent(root_tracker_id),
                  &pending_trackers);
 
-  std::vector<int64> to_be_removed;
+  std::vector<int64_t> to_be_removed;
 
   // List trackers to remove.
   while (!pending_trackers.empty()) {
-    int64 tracker_id = pending_trackers.back();
+    int64_t tracker_id = pending_trackers.back();
     pending_trackers.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id),
                    &pending_trackers);
     to_be_removed.push_back(tracker_id);
   }
 
   // Remove trackers in the reversed order.
   base::hash_set<std::string> affected_file_ids;
-  for (std::vector<int64>::reverse_iterator itr = to_be_removed.rbegin();
+  for (std::vector<int64_t>::reverse_iterator itr = to_be_removed.rbegin();
        itr != to_be_removed.rend(); ++itr) {
     FileTracker tracker;
     index->GetFileTracker(*itr, &tracker);
     affected_file_ids.insert(tracker.file_id());
     index->RemoveFileTracker(*itr);
   }
 
   for (base::hash_set<std::string>::iterator itr = affected_file_ids.begin();
        itr != affected_file_ids.end(); ++itr) {
     TrackerIDSet trackers = index->GetFileTrackerIDsByFileID(*itr);
     if (trackers.empty()) {
       // Remove metadata that no longer has any tracker.
       index->RemoveFileMetadata(*itr);
     } else {
       MarkTrackerSetDirty(trackers, index);
     }
   }
 }
 
-bool FilterFileTrackersByParent(
-    const MetadataDatabaseIndexInterface* index,
-    const TrackerIDSet& trackers,
-    int64 parent_tracker_id,
-    FileTracker* tracker_out) {
+bool FilterFileTrackersByParent(const MetadataDatabaseIndexInterface* index,
+                                const TrackerIDSet& trackers,
+                                int64_t parent_tracker_id,
+                                FileTracker* tracker_out) {
   FileTracker tracker;
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     if (!index->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
 
     if (tracker.parent_tracker_id() == parent_tracker_id) {
       if (tracker_out)
         tracker_out->CopyFrom(tracker);
       return true;
     }
   }
   return false;
 }
 
 bool FilterFileTrackersByParentAndTitle(
     const MetadataDatabaseIndexInterface* index,
     const TrackerIDSet& trackers,
-    int64 parent_tracker_id,
+    int64_t parent_tracker_id,
     const std::string& title,
     FileTracker* result) {
   bool found = false;
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     FileTracker tracker;
     if (!index->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
@@ skipping 41 matching lines @@
   return false;
 }
 
 enum DirtyingOption {
   MARK_NOTHING_DIRTY = 0,
   MARK_ITSELF_DIRTY = 1 << 0,
   MARK_SAME_FILE_ID_TRACKERS_DIRTY = 1 << 1,
   MARK_SAME_PATH_TRACKERS_DIRTY = 1 << 2,
 };
 
-void ActivateFileTracker(int64 tracker_id,
+void ActivateFileTracker(int64_t tracker_id,
                          int dirtying_options,
                          MetadataDatabaseIndexInterface* index) {
   DCHECK(dirtying_options == MARK_NOTHING_DIRTY ||
          dirtying_options == MARK_ITSELF_DIRTY);
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
   tracker->set_active(true);
   if (dirtying_options & MARK_ITSELF_DIRTY) {
     tracker->set_dirty(true);
     tracker->set_needs_folder_listing(
         tracker->has_synced_details() &&
         tracker->synced_details().file_kind() == FILE_KIND_FOLDER);
   } else {
     tracker->set_dirty(false);
     tracker->set_needs_folder_listing(false);
   }
 
   index->StoreFileTracker(tracker.Pass());
 }
 
-void DeactivateFileTracker(int64 tracker_id,
+void DeactivateFileTracker(int64_t tracker_id,
                            int dirtying_options,
                            MetadataDatabaseIndexInterface* index) {
   RemoveAllDescendantTrackers(tracker_id, index);
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
     MarkTrackersDirtyByFileID(tracker->file_id(), index);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY) {
     MarkTrackersDirtyByPath(tracker->parent_tracker_id(),
                             GetTrackerTitle(*tracker), index);
   }
 
   tracker->set_dirty(dirtying_options & MARK_ITSELF_DIRTY);
   tracker->set_active(false);
   index->StoreFileTracker(tracker.Pass());
 }
 
-void RemoveFileTracker(int64 tracker_id,
+void RemoveFileTracker(int64_t tracker_id,
                        int dirtying_options,
                        MetadataDatabaseIndexInterface* index) {
   DCHECK(!(dirtying_options & MARK_ITSELF_DIRTY));
 
   FileTracker tracker;
   if (!index->GetFileTracker(tracker_id, &tracker))
     return;
 
   std::string file_id = tracker.file_id();
-  int64 parent_tracker_id = tracker.parent_tracker_id();
+  int64_t parent_tracker_id = tracker.parent_tracker_id();
   std::string title = GetTrackerTitle(tracker);
 
   RemoveAllDescendantTrackers(tracker_id, index);
   index->RemoveFileTracker(tracker_id);
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
     MarkTrackersDirtyByFileID(file_id, index);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY)
     MarkTrackersDirtyByPath(parent_tracker_id, title, index);
 
@@ skipping 70 matching lines @@
 void MetadataDatabase::ClearDatabase(
     scoped_ptr<MetadataDatabase> metadata_database) {
   DCHECK(metadata_database);
   base::FilePath database_path = metadata_database->database_path_;
   DCHECK(!database_path.empty());
   metadata_database.reset();
 
   base::DeleteFile(database_path, true /* recursive */);
 }
 
-int64 MetadataDatabase::GetLargestFetchedChangeID() const {
+int64_t MetadataDatabase::GetLargestFetchedChangeID() const {
   return index_->GetLargestChangeID();
 }
 
-int64 MetadataDatabase::GetSyncRootTrackerID() const {
+int64_t MetadataDatabase::GetSyncRootTrackerID() const {
   return index_->GetSyncRootTrackerID();
 }
 
-int64 MetadataDatabase::GetLargestKnownChangeID() const {
+int64_t MetadataDatabase::GetLargestKnownChangeID() const {
   DCHECK_LE(GetLargestFetchedChangeID(), largest_known_change_id_);
   return largest_known_change_id_;
 }
 
-void MetadataDatabase::UpdateLargestKnownChangeID(int64 change_id) {
+void MetadataDatabase::UpdateLargestKnownChangeID(int64_t change_id) {
   if (largest_known_change_id_ < change_id)
     largest_known_change_id_ = change_id;
 }
 
 bool MetadataDatabase::NeedsSyncRootRevalidation() const {
   return !index_->IsSyncRootRevalidated();
 }
 
 bool MetadataDatabase::HasSyncRoot() const {
   return index_->GetSyncRootTrackerID() != kInvalidTrackerID;
 }
 
 SyncStatusCode MetadataDatabase::PopulateInitialData(
-    int64 largest_change_id,
+    int64_t largest_change_id,
     const google_apis::FileResource& sync_root_folder,
     const ScopedVector<google_apis::FileResource>& app_root_folders) {
   index_->SetLargestChangeID(largest_change_id);
   UpdateLargestKnownChangeID(largest_change_id);
 
   AttachSyncRoot(sync_root_folder);
   for (size_t i = 0; i < app_root_folders.size(); ++i)
     AttachInitialAppRoot(*app_root_folders[i]);
 
   if (NeedsSyncRootRevalidation()) {
     index_->RemoveUnreachableItems();
     index_->SetSyncRootRevalidated();
   }
 
   return WriteToDatabase();
 }
 
 bool MetadataDatabase::IsAppEnabled(const std::string& app_id) const {
-  int64 tracker_id = index_->GetAppRootTracker(app_id);
+  int64_t tracker_id = index_->GetAppRootTracker(app_id);
   if (tracker_id == kInvalidTrackerID)
     return false;
 
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker))
     return false;
   return tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
 }
 
 SyncStatusCode MetadataDatabase::RegisterApp(const std::string& app_id,
                                    const std::string& folder_id) {
   if (index_->GetAppRootTracker(app_id)) {
     // The app-root is already registered.
     return SYNC_STATUS_OK;
   }
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (trackers.empty()) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (trackers.has_active()) {
     // The folder is tracked by another tracker.
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Failed to register App for %s", app_id.c_str());
     return SYNC_STATUS_HAS_CONFLICT;
   }
 
-  int64 sync_root_tracker_id = index_->GetSyncRootTrackerID();
+  int64_t sync_root_tracker_id = index_->GetSyncRootTrackerID();
   if (!sync_root_tracker_id) {
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Sync-root needs to be set up before registering app-root");
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!FilterFileTrackersByParent(index_.get(), trackers,
                                   sync_root_tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   tracker->set_app_id(app_id);
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(tracker.Pass());
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::DisableApp(const std::string& app_id) {
-  int64 tracker_id = index_->GetAppRootTracker(app_id);
+  int64_t tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
     return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   // Keep the app-root tracker active (but change the tracker_kind) so that
   // other conflicting trackers won't become active.
   tracker->set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
 
   index_->StoreFileTracker(tracker.Pass());
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::EnableApp(const std::string& app_id) {
-  int64 tracker_id = index_->GetAppRootTracker(app_id);
+  int64_t tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_APP_ROOT) {
     return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   index_->StoreFileTracker(tracker.Pass());
 
   MarkTrackersDirtyRecursively(tracker_id, index_.get());
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UnregisterApp(const std::string& app_id) {
-  int64 tracker_id = index_->GetAppRootTracker(app_id);
+  int64_t tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get()) ||
       tracker->tracker_kind() == TRACKER_KIND_REGULAR) {
     return SYNC_STATUS_OK;
   }
 
   RemoveAllDescendantTrackers(tracker_id, index_.get());
 
   tracker->clear_app_id();
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_active(false);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(tracker.Pass());
   return WriteToDatabase();
 }
 
 bool MetadataDatabase::FindAppRootTracker(const std::string& app_id,
                                           FileTracker* tracker_out) const {
-  int64 app_root_tracker_id = index_->GetAppRootTracker(app_id);
+  int64_t app_root_tracker_id = index_->GetAppRootTracker(app_id);
   if (!app_root_tracker_id)
     return false;
 
   if (tracker_out &&
       !index_->GetFileTracker(app_root_tracker_id, tracker_out)) {
     NOTREACHED();
     return false;
   }
 
   return true;
 }
 
 bool MetadataDatabase::FindFileByFileID(const std::string& file_id,
                                         FileMetadata* metadata_out) const {
   return index_->GetFileMetadata(file_id, metadata_out);
 }
 
 bool MetadataDatabase::FindTrackersByFileID(const std::string& file_id,
                                             TrackerIDSet* trackers_out) const {
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (trackers.empty())
     return false;
 
   if (trackers_out)
     std::swap(trackers, *trackers_out);
   return true;
 }
 
 bool MetadataDatabase::FindTrackersByParentAndTitle(
-    int64 parent_tracker_id,
+    int64_t parent_tracker_id,
     const std::string& title,
     TrackerIDSet* trackers_out) const {
   TrackerIDSet trackers =
       index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title);
   if (trackers.empty())
     return false;
 
   if (trackers_out)
     std::swap(trackers, *trackers_out);
   return true;
 }
 
-bool MetadataDatabase::FindTrackerByTrackerID(int64 tracker_id,
+bool MetadataDatabase::FindTrackerByTrackerID(int64_t tracker_id,
                                               FileTracker* tracker_out) const {
   return index_->GetFileTracker(tracker_id, tracker_out);
 }
 
-bool MetadataDatabase::BuildPathForTracker(int64 tracker_id,
+bool MetadataDatabase::BuildPathForTracker(int64_t tracker_id,
                                            base::FilePath* path) const {
   FileTracker current;
   if (!FindTrackerByTrackerID(tracker_id, &current) || !current.active())
     return false;
 
   std::vector<base::FilePath> components;
   while (!IsAppRoot(current)) {
     std::string title = GetTrackerTitle(current);
     if (title.empty())
       return false;
@@ skipping 64 matching lines @@
     }
 
     tracker_out->CopyFrom(tracker);
     *path_out = path_out->Append(components[i]);
   }
 
   return true;
 }
 
 SyncStatusCode MetadataDatabase::UpdateByChangeList(
-    int64 largest_change_id,
+    int64_t largest_change_id,
     ScopedVector<google_apis::ChangeResource> changes) {
   DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
@@ skipping 43 matching lines @@
        itr != file_ids.end(); ++itr) {
     scoped_ptr<FileMetadata> metadata(
         CreateDeletedFileMetadata(GetLargestKnownChangeID(), *itr));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::ReplaceActiveTrackerWithNewResource(
-    int64 parent_tracker_id,
+    int64_t parent_tracker_id,
     const google_apis::FileResource& resource) {
   DCHECK(!index_->GetFileMetadata(resource.file_id(), nullptr));
   DCHECK(index_->GetFileTracker(parent_tracker_id, nullptr));
 
   UpdateByFileMetadata(
       FROM_HERE,
       CreateFileMetadataFromFileResource(GetLargestKnownChangeID(), resource),
       UPDATE_TRACKER_FOR_SYNCED_FILE);
 
   DCHECK(index_->GetFileMetadata(resource.file_id(), nullptr));
   DCHECK(!index_->GetFileTrackerIDsByFileID(resource.file_id()).has_active());
 
   TrackerIDSet same_path_trackers =
       index_->GetFileTrackerIDsByParentAndTitle(
           parent_tracker_id, resource.title());
   FileTracker to_be_activated;
   if (!FilterFileTrackersByFileID(index_.get(), same_path_trackers,
                                   resource.file_id(), &to_be_activated)) {
     NOTREACHED();
     return SYNC_STATUS_FAILED;
   }
 
-  int64 tracker_id = to_be_activated.tracker_id();
+  int64_t tracker_id = to_be_activated.tracker_id();
   if (same_path_trackers.has_active()) {
     DeactivateFileTracker(same_path_trackers.active_tracker(),
                           MARK_ITSELF_DIRTY |
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
                           index_.get());
   }
 
   ActivateFileTracker(tracker_id, MARK_NOTHING_DIRTY, index_.get());
   return WriteToDatabase();
 }
@@ skipping 11 matching lines @@
   scoped_ptr<FileTracker> folder_tracker(new FileTracker);
   if (!index_->GetFileTracker(trackers.active_tracker(),
                               folder_tracker.get())) {
     NOTREACHED();
     return SYNC_STATUS_FAILED;
   }
 
   base::hash_set<std::string> children(child_file_ids.begin(),
                                        child_file_ids.end());
 
-  std::vector<int64> known_children =
+  std::vector<int64_t> known_children =
       index_->GetFileTrackerIDsByParent(folder_tracker->tracker_id());
   for (size_t i = 0; i < known_children.size(); ++i) {
     FileTracker tracker;
     if (!index_->GetFileTracker(known_children[i], &tracker)) {
       NOTREACHED();
       continue;
     }
     children.erase(tracker.file_id());
   }
 
   for (base::hash_set<std::string>::const_iterator itr = children.begin();
        itr != children.end(); ++itr)
     CreateTrackerForParentAndFileID(*folder_tracker, *itr);
   folder_tracker->set_needs_folder_listing(false);
   if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker))
     folder_tracker->set_dirty(false);
   index_->StoreFileTracker(folder_tracker.Pass());
 
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UpdateTracker(
-    int64 tracker_id,
+    int64_t tracker_id,
     const FileDetails& updated_details) {
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker)) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   // Check if the tracker is to be deleted.
   if (updated_details.missing()) {
     FileMetadata metadata;
     if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
@@ skipping 74 matching lines @@
     updated_tracker->set_dirty(false);
   }
   index_->StoreFileTracker(updated_tracker.Pass());
   if (should_promote)
     index_->PromoteDemotedDirtyTracker(tracker_id);
 
   return WriteToDatabase();
 }
 
 MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
-    int64 parent_tracker_id,
+    int64_t parent_tracker_id,
     const std::string& file_id,
     SyncStatusCode* status_out) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata)) {
     NOTREACHED();
     *status_out = SYNC_STATUS_FAILED;
     return ACTIVATION_PENDING;
   }
   std::string title = metadata.details().title();
   DCHECK(!HasInvalidTitle(title));
@@ skipping 43 matching lines @@
     tracker_to_be_activated->set_needs_folder_listing(true);
   }
   tracker_to_be_activated->set_dirty(false);
 
   index_->StoreFileTracker(tracker_to_be_activated.Pass());
 
   *status_out = WriteToDatabase();
   return ACTIVATION_PENDING;
 }
 
-void MetadataDatabase::DemoteTracker(int64 tracker_id) {
+void MetadataDatabase::DemoteTracker(int64_t tracker_id) {
   index_->DemoteDirtyTracker(tracker_id);
   WriteToDatabase();
 }
 
 bool MetadataDatabase::PromoteDemotedTrackers() {
   bool promoted = index_->PromoteDemotedDirtyTrackers();
   WriteToDatabase();
   return promoted;
 }
 
-void MetadataDatabase::PromoteDemotedTracker(int64 tracker_id) {
+void MetadataDatabase::PromoteDemotedTracker(int64_t tracker_id) {
   index_->PromoteDemotedDirtyTracker(tracker_id);
   WriteToDatabase();
 }
 
 bool MetadataDatabase::GetDirtyTracker(
     FileTracker* tracker_out) const {
-  int64 dirty_tracker_id = index_->PickDirtyTracker();
+  int64_t dirty_tracker_id = index_->PickDirtyTracker();
   if (!dirty_tracker_id)
     return false;
 
   if (tracker_out) {
     if (!index_->GetFileTracker(dirty_tracker_id, tracker_out)) {
       NOTREACHED();
       return false;
     }
   }
   return true;
@@ skipping 57 matching lines @@
   return true;
 }
 
 void MetadataDatabase::GetRegisteredAppIDs(std::vector<std::string>* app_ids) {
   DCHECK(app_ids);
   *app_ids = index_->GetRegisteredAppIDs();
 }
 
 SyncStatusCode MetadataDatabase::SweepDirtyTrackers(
     const std::vector<std::string>& file_ids) {
-  std::set<int64> tracker_ids;
+  std::set<int64_t> tracker_ids;
   for (size_t i = 0; i < file_ids.size(); ++i) {
     TrackerIDSet trackers_for_file_id =
         index_->GetFileTrackerIDsByFileID(file_ids[i]);
     for (TrackerIDSet::iterator itr = trackers_for_file_id.begin();
          itr != trackers_for_file_id.end(); ++itr)
       tracker_ids.insert(*itr);
   }
 
-  for (std::set<int64>::iterator itr = tracker_ids.begin();
+  for (std::set<int64_t>::iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     if (!index_->GetFileTracker(*itr, tracker.get()) ||
         !CanClearDirty(*tracker))
       continue;
     tracker->set_dirty(false);
     index_->StoreFileTracker(tracker.Pass());
   }
 
   return WriteToDatabase();
@@ skipping 66 matching lines @@
   CreateTrackerInternal(parent_tracker,
                         file_metadata.file_id(),
                         &file_metadata.details(),
                         option);
 }
 
 void MetadataDatabase::CreateTrackerInternal(const FileTracker& parent_tracker,
                                              const std::string& file_id,
                                              const FileDetails* details,
                                              UpdateOption option) {
-  int64 tracker_id = IncrementTrackerID();
+  int64_t tracker_id = IncrementTrackerID();
   scoped_ptr<FileTracker> tracker(new FileTracker);
   tracker->set_tracker_id(tracker_id);
   tracker->set_parent_tracker_id(parent_tracker.tracker_id());
   tracker->set_file_id(file_id);
   tracker->set_app_id(parent_tracker.app_id());
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_dirty(true);
   tracker->set_active(false);
   tracker->set_needs_folder_listing(false);
   if (details) {
     *tracker->mutable_synced_details() = *details;
     if (option == UPDATE_TRACKER_FOR_UNSYNCED_FILE) {
       tracker->mutable_synced_details()->set_missing(true);
       tracker->mutable_synced_details()->clear_md5();
     }
   }
   index_->StoreFileTracker(tracker.Pass());
 }
 
 void MetadataDatabase::MaybeAddTrackersForNewFile(
     const FileMetadata& metadata,
     UpdateOption option) {
-  std::set<int64> parents_to_exclude;
+  std::set<int64_t> parents_to_exclude;
   TrackerIDSet existing_trackers =
       index_->GetFileTrackerIDsByFileID(metadata.file_id());
   for (TrackerIDSet::const_iterator itr = existing_trackers.begin();
        itr != existing_trackers.end(); ++itr) {
     FileTracker tracker;
     if (!index_->GetFileTracker(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
 
-    int64 parent_tracker_id = tracker.parent_tracker_id();
+    int64_t parent_tracker_id = tracker.parent_tracker_id();
     if (!parent_tracker_id)
       continue;
 
     // Exclude |parent_tracker_id| if it already has a tracker that has
     // unknown title or has the same title with |file|.
     if (!tracker.has_synced_details() ||
         tracker.synced_details().title() == metadata.details().title()) {
       parents_to_exclude.insert(parent_tracker_id);
     }
   }
@@ skipping 11 matching lines @@
 
       if (ContainsKey(parents_to_exclude, parent_tracker.tracker_id()))
         continue;
 
       CreateTrackerForParentAndFileMetadata(
           parent_tracker, metadata, option);
     }
   }
 }
 
-int64 MetadataDatabase::IncrementTrackerID() {
-  int64 tracker_id = index_->GetNextTrackerID();
+int64_t MetadataDatabase::IncrementTrackerID() {
+  int64_t tracker_id = index_->GetNextTrackerID();
   index_->SetNextTrackerID(tracker_id + 1);
   DCHECK_GT(tracker_id, 0);
   return tracker_id;
 }
 
 bool MetadataDatabase::CanActivateTracker(const FileTracker& tracker) {
   DCHECK(!tracker.active());
   DCHECK_NE(index_->GetSyncRootTrackerID(), tracker.tracker_id());
 
   if (HasActiveTrackerForFileID(tracker.file_id()))
@@ skipping 41 matching lines @@
       return true;
   }
 
   if (local_details.title() != remote_details.title())
     return true;
 
   return false;
 }
 
 bool MetadataDatabase::HasDisabledAppRoot(const FileTracker& tracker) const {
-  int64 app_root_tracker_id = index_->GetAppRootTracker(tracker.app_id());
+  int64_t app_root_tracker_id = index_->GetAppRootTracker(tracker.app_id());
   if (app_root_tracker_id == kInvalidTrackerID)
     return false;
 
   FileTracker app_root_tracker;
   if (!index_->GetFileTracker(app_root_tracker_id, &app_root_tracker)) {
     NOTREACHED();
     return false;
   }
   return app_root_tracker.tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT;
 }
 
 bool MetadataDatabase::HasActiveTrackerForFileID(
     const std::string& file_id) const {
   return index_->GetFileTrackerIDsByFileID(file_id).has_active();
 }
 
-bool MetadataDatabase::HasActiveTrackerForPath(int64 parent_tracker_id,
+bool MetadataDatabase::HasActiveTrackerForPath(int64_t parent_tracker_id,
                                                const std::string& title) const {
   return index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title)
       .has_active();
 }
 
 void MetadataDatabase::RemoveUnneededTrackersForMissingFile(
     const std::string& file_id) {
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
@@ skipping 42 matching lines @@
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     const std::string& app_id) {
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   FileTracker app_root_tracker;
   if (!FindAppRootTracker(app_id, &app_root_tracker))
     return files.Pass();
 
-  std::vector<int64> stack;
+  std::vector<int64_t> stack;
   AppendContents(
       index_->GetFileTrackerIDsByParent(app_root_tracker.tracker_id()), &stack);
   while (!stack.empty()) {
-    int64 tracker_id = stack.back();
+    int64_t tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index_->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     FileTracker tracker;
     if (!index_->GetFileTracker(tracker_id, &tracker)) {
       NOTREACHED();
       continue;
     }
     base::DictionaryValue* file = new base::DictionaryValue;
 
@@ skipping 22 matching lines @@
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
   scoped_ptr<base::ListValue> list(new base::ListValue);
   list->Append(DumpTrackers().release());
   list->Append(DumpMetadata().release());
   return list.Pass();
 }
 
 bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
-                                            int64 change_id) {
+                                            int64_t change_id) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata))
     return false;
   DCHECK(metadata.has_details());
   return metadata.details().change_id() >= change_id;
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
   scoped_ptr<base::ListValue> trackers(new base::ListValue);
 
   // Append the first element for metadata.
   base::DictionaryValue* metadata = new base::DictionaryValue;
   const char *trackerKeys[] = {
     "tracker_id", "path", "file_id", "tracker_kind", "app_id",
     "active", "dirty", "folder_listing", "demoted",
     "title", "kind", "md5", "etag", "missing", "change_id",
   };
   std::vector<std::string> key_strings(
       trackerKeys, trackerKeys + arraysize(trackerKeys));
   base::ListValue* keys = new base::ListValue;
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Trackers");
   metadata->Set("keys", keys);
   trackers->Append(metadata);
 
   // Append tracker data.
-  std::vector<int64> tracker_ids(index_->GetAllTrackerIDs());
-  for (std::vector<int64>::const_iterator itr = tracker_ids.begin();
+  std::vector<int64_t> tracker_ids(index_->GetAllTrackerIDs());
+  for (std::vector<int64_t>::const_iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
-    const int64 tracker_id = *itr;
+    const int64_t tracker_id = *itr;
     FileTracker tracker;
     if (!index_->GetFileTracker(tracker_id, &tracker)) {
       NOTREACHED();
       continue;
     }
 
     base::DictionaryValue* dict = new base::DictionaryValue;
     base::FilePath path = BuildDisplayPathForTracker(tracker);
     dict->SetString("tracker_id", base::Int64ToString(tracker_id));
     dict->SetString("path", path.AsUTF8Unsafe());
@@ skipping 127 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system