Switch to standard integer types in sync/.

sync/syncable/directory.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 "sync/syncable/directory.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <iterator>
 
 #include "base/base64.h"
 #include "base/guid.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
@@ skipping 122 matching lines @@
 }
 
 void Directory::InitializeIndices(MetahandlesMap* handles_map) {
   ScopedKernelLock lock(this);
   kernel_->metahandles_map.swap(*handles_map);
   for (MetahandlesMap::const_iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
     EntryKernel* entry = it->second;
     if (ParentChildIndex::ShouldInclude(entry))
       kernel_->parent_child_index.Insert(entry);
-    const int64 metahandle = entry->ref(META_HANDLE);
+    const int64_t metahandle = entry->ref(META_HANDLE);
     if (entry->ref(IS_UNSYNCED))
       kernel_->unsynced_metahandles.insert(metahandle);
     if (entry->ref(IS_UNAPPLIED_UPDATE)) {
       const ModelType type = entry->GetServerModelType();
       kernel_->unapplied_update_metahandles[type].insert(metahandle);
     }
     if (!entry->ref(UNIQUE_SERVER_TAG).empty()) {
       DCHECK(kernel_->server_tags_map.find(entry->ref(UNIQUE_SERVER_TAG)) ==
              kernel_->server_tags_map.end())
           << "Unexpected duplicate use of client tag";
@@ skipping 107 matching lines @@
 EntryKernel* Directory::GetEntryByServerTag(const string& tag) {
   ScopedKernelLock lock(this);
   DCHECK(kernel_);
   TagsMap::iterator it = kernel_->server_tags_map.find(tag);
   if (it != kernel_->server_tags_map.end()) {
     return it->second;
   }
   return NULL;
 }
 
-EntryKernel* Directory::GetEntryByHandle(int64 metahandle) {
+EntryKernel* Directory::GetEntryByHandle(int64_t metahandle) {
   ScopedKernelLock lock(this);
   return GetEntryByHandle(lock, metahandle);
 }
 
 EntryKernel* Directory::GetEntryByHandle(const ScopedKernelLock& lock,
-                                         int64 metahandle) {
+                                         int64_t metahandle) {
   // Look up in memory
   MetahandlesMap::iterator found =
       kernel_->metahandles_map.find(metahandle);
   if (found != kernel_->metahandles_map.end()) {
     // Found it in memory.  Easy.
     return found->second;
   }
   return NULL;
 }
 
@@ skipping 140 matching lines @@
     // Update the indices that depend on the PARENT_ID field.
     ScopedParentChildIndexUpdater index_updater(lock, entry,
         &kernel_->parent_child_index);
     entry->put(PARENT_ID, new_parent_id);
   }
   return true;
 }
 
 void Directory::RemoveFromAttachmentIndex(
     const ScopedKernelLock& lock,
-    const int64 metahandle,
+    const int64_t metahandle,
     const sync_pb::AttachmentMetadata& attachment_metadata) {
   for (int i = 0; i < attachment_metadata.record_size(); ++i) {
     AttachmentIdUniqueId unique_id =
         attachment_metadata.record(i).id().unique_id();
     IndexByAttachmentId::iterator iter =
         kernel_->index_by_attachment_id.find(unique_id);
     if (iter != kernel_->index_by_attachment_id.end()) {
       iter->second.erase(metahandle);
       if (iter->second.empty()) {
         kernel_->index_by_attachment_id.erase(iter);
       }
     }
   }
 }
 
 void Directory::AddToAttachmentIndex(
     const ScopedKernelLock& lock,
-    const int64 metahandle,
+    const int64_t metahandle,
     const sync_pb::AttachmentMetadata& attachment_metadata) {
   for (int i = 0; i < attachment_metadata.record_size(); ++i) {
     AttachmentIdUniqueId unique_id =
         attachment_metadata.record(i).id().unique_id();
     IndexByAttachmentId::iterator iter =
         kernel_->index_by_attachment_id.find(unique_id);
     if (iter == kernel_->index_by_attachment_id.end()) {
       iter = kernel_->index_by_attachment_id.insert(std::make_pair(
                                                         unique_id,
                                                         MetahandleSet())).first;
     }
     iter->second.insert(metahandle);
   }
 }
 
 void Directory::UpdateAttachmentIndex(
-    const int64 metahandle,
+    const int64_t metahandle,
     const sync_pb::AttachmentMetadata& old_metadata,
     const sync_pb::AttachmentMetadata& new_metadata) {
   ScopedKernelLock lock(this);
   RemoveFromAttachmentIndex(lock, metahandle, old_metadata);
   AddToAttachmentIndex(lock, metahandle, new_metadata);
 }
 
 void Directory::GetMetahandlesByAttachmentId(
     BaseTransaction* trans,
     const sync_pb::AttachmentIdProto& attachment_id_proto,
@@ skipping 20 matching lines @@
   kernel_->dirty_metahandles.clear();
 }
 
 bool Directory::SafeToPurgeFromMemory(WriteTransaction* trans,
                                       const EntryKernel* const entry) const {
   bool safe = entry->ref(IS_DEL) && !entry->is_dirty() &&
       !entry->ref(SYNCING) && !entry->ref(IS_UNAPPLIED_UPDATE) &&
       !entry->ref(IS_UNSYNCED);
 
   if (safe) {
-    int64 handle = entry->ref(META_HANDLE);
+    int64_t handle = entry->ref(META_HANDLE);
     const ModelType type = entry->GetServerModelType();
     if (!SyncAssert(kernel_->dirty_metahandles.count(handle) == 0U,
                     FROM_HERE,
                     "Dirty metahandles should be empty", trans))
       return false;
     // TODO(tim): Bug 49278.
     if (!SyncAssert(!kernel_->unsynced_metahandles.count(handle),
                     FROM_HERE,
                     "Unsynced handles should be empty",
                     trans))
@@ skipping 109 matching lines @@
 
       delete entry;
     }
     if (trans.unrecoverable_error_set())
       return false;
   }
   return true;
 }
 
 void Directory::UnapplyEntry(EntryKernel* entry) {
-  int64 handle = entry->ref(META_HANDLE);
+  int64_t handle = entry->ref(META_HANDLE);
   ModelType server_type = GetModelTypeFromSpecifics(
       entry->ref(SERVER_SPECIFICS));
 
   // Clear enough so that on the next sync cycle all local data will
   // be overwritten.
   // Note: do not modify the root node in order to preserve the
   // initial sync ended bit for this type (else on the next restart
   // this type will be treated as disabled and therefore fully purged).
   if (entry->ref(PARENT_ID).IsRoot()) {
     ModelType root_type = server_type;
@@ skipping 38 matching lines @@
   // At this point locally created items that aren't synced will become locally
   // deleted items, and purged on the next snapshot. All other items will match
   // the state they would have had if they were just created via a server
   // update. See MutableEntry::MutableEntry(.., CreateNewUpdateItem, ..).
 }
 
 void Directory::DeleteEntry(const ScopedKernelLock& lock,
                             bool save_to_journal,
                             EntryKernel* entry,
                             EntryKernelSet* entries_to_journal) {
-  int64 handle = entry->ref(META_HANDLE);
+  int64_t handle = entry->ref(META_HANDLE);
   ModelType server_type = GetModelTypeFromSpecifics(
       entry->ref(SERVER_SPECIFICS));
 
   kernel_->metahandles_to_purge.insert(handle);
 
   size_t num_erased = 0;
   num_erased = kernel_->metahandles_map.erase(entry->ref(META_HANDLE));
   DCHECK_EQ(1u, num_erased);
   num_erased = kernel_->ids_map.erase(entry->ref(ID).value());
   DCHECK_EQ(1u, num_erased);
@@ skipping 219 matching lines @@
   ScopedKernelLock lock(this);
   kernel_->persisted_info.download_progress[model_type].CopyFrom(new_progress);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 bool Directory::HasEmptyDownloadProgress(ModelType type) const {
   ScopedKernelLock lock(this);
   return kernel_->persisted_info.HasEmptyDownloadProgress(type);
 }
 
-int64 Directory::GetTransactionVersion(ModelType type) const {
+int64_t Directory::GetTransactionVersion(ModelType type) const {
   kernel_->transaction_mutex.AssertAcquired();
   return kernel_->persisted_info.transaction_version[type];
 }
 
 void Directory::IncrementTransactionVersion(ModelType type) {
   kernel_->transaction_mutex.AssertAcquired();
   kernel_->persisted_info.transaction_version[type]++;
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
@@ skipping 118 matching lines @@
 }
 
 void Directory::GetUnsyncedMetaHandles(BaseTransaction* trans,
                                        Metahandles* result) {
   result->clear();
   ScopedKernelLock lock(this);
   copy(kernel_->unsynced_metahandles.begin(),
        kernel_->unsynced_metahandles.end(), back_inserter(*result));
 }
 
-int64 Directory::unsynced_entity_count() const {
+int64_t Directory::unsynced_entity_count() const {
   ScopedKernelLock lock(this);
   return kernel_->unsynced_metahandles.size();
 }
 
 bool Directory::TypeHasUnappliedUpdates(ModelType type) {
   ScopedKernelLock lock(this);
   return !kernel_->unapplied_update_metahandles[type].empty();
 }
 
-void Directory::GetUnappliedUpdateMetaHandles(
-    BaseTransaction* trans,
-    FullModelTypeSet server_types,
-    std::vector<int64>* result) {
+void Directory::GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
+                                              FullModelTypeSet server_types,
+                                              std::vector<int64_t>* result) {
   result->clear();
   ScopedKernelLock lock(this);
   for (int i = UNSPECIFIED; i < MODEL_TYPE_COUNT; ++i) {
     const ModelType type = ModelTypeFromInt(i);
     if (server_types.Has(type)) {
       std::copy(kernel_->unapplied_update_metahandles[type].begin(),
                 kernel_->unapplied_update_metahandles[type].end(),
                 back_inserter(*result));
     }
   }
 }
 
 void Directory::GetMetaHandlesOfType(BaseTransaction* trans,
                                      ModelType type,
-                                     std::vector<int64>* result) {
+                                     std::vector<int64_t>* result) {
   ScopedKernelLock lock(this);
   GetMetaHandlesOfType(lock, trans, type, result);
 }
 
 void Directory::GetMetaHandlesOfType(const ScopedKernelLock& lock,
                                      BaseTransaction* trans,
                                      ModelType type,
-                                     std::vector<int64>* result) {
+                                     std::vector<int64_t>* result) {
   result->clear();
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
     EntryKernel* entry = it->second;
     const ModelType entry_type =
         GetModelTypeFromSpecifics(entry->ref(SPECIFICS));
     if (entry_type == type)
       result->push_back(it->first);
   }
 }
@@ skipping 68 matching lines @@
 bool Directory::FullyCheckTreeInvariants(syncable::BaseTransaction* trans) {
   MetahandleSet handles;
   GetAllMetaHandles(trans, &handles);
   return CheckTreeInvariants(trans, handles);
 }
 
 bool Directory::CheckTreeInvariants(syncable::BaseTransaction* trans,
                                     const MetahandleSet& handles) {
   MetahandleSet::const_iterator i;
   for (i = handles.begin() ; i != handles.end() ; ++i) {
-    int64 metahandle = *i;
+    int64_t metahandle = *i;
     Entry e(trans, GET_BY_HANDLE, metahandle);
     if (!SyncAssert(e.good(), FROM_HERE, "Entry is bad", trans))
       return false;
     syncable::Id id = e.GetId();
     syncable::Id parentid = e.GetParentId();
 
     if (id.IsRoot()) {
       if (!SyncAssert(e.GetIsDir(), FROM_HERE,
                       "Entry should be a directory",
                       trans))
@@ skipping 37 matching lines @@
           if (!SyncAssert(handles.end() != handles.find(parent.GetMetahandle()),
                           FROM_HERE, "Parent should be in the index.", trans))
             return false;
           parentid = parent.GetParentId();
           if (!SyncAssert(--safety_count > 0, FROM_HERE,
                           "Count should be greater than zero.", trans))
             return false;
         }
       }
     }
-    int64 base_version = e.GetBaseVersion();
-    int64 server_version = e.GetServerVersion();
+    int64_t base_version = e.GetBaseVersion();
+    int64_t server_version = e.GetServerVersion();
     bool using_unique_client_tag = !e.GetUniqueClientTag().empty();
     if (CHANGES_VERSION == base_version || 0 == base_version) {
       ModelType model_type = e.GetModelType();
       bool is_client_creatable_type_root_folder =
           parentid.IsRoot() &&
           IsTypeWithClientGeneratedRoot(model_type) &&
           e.GetUniqueServerTag() == ModelTypeToRootTag(model_type);
       if (e.GetIsUnappliedUpdate()) {
         // Must be a new item, or a de-duplicated unique client tag
         // that was created both locally and remotely, or a type root folder
@@ skipping 71 matching lines @@
     // This is not always true in the case that an item is deleted while the
     // initial commit is in flight. See crbug.com/426865.
   }
   return true;
 }
 
 void Directory::SetInvariantCheckLevel(InvariantCheckLevel check_level) {
   invariant_check_level_ = check_level;
 }
 
-int64 Directory::NextMetahandle() {
+int64_t Directory::NextMetahandle() {
   ScopedKernelLock lock(this);
-  int64 metahandle = (kernel_->next_metahandle)++;
+  int64_t metahandle = (kernel_->next_metahandle)++;
   return metahandle;
 }
 
 // Generates next client ID based on a randomly generated GUID.
 Id Directory::NextId() {
   return Id::CreateFromClientString(base::GenerateGUID());
 }
 
 bool Directory::HasChildren(BaseTransaction* trans, const Id& id) {
   ScopedKernelLock lock(this);
@@ skipping 158 matching lines @@
                                          ModelType type,
                                          AttachmentIdList* ids) {
   // TODO(maniscalco): Maintain an index by ModelType and rewrite this method to
   // use it.  The approach below is likely very expensive because it iterates
   // all entries (bug 415199).
   DCHECK(trans);
   DCHECK(ids);
   ids->clear();
   AttachmentIdSet on_server_id_set;
   AttachmentIdSet not_on_server_id_set;
-  std::vector<int64> metahandles;
+  std::vector<int64_t> metahandles;
   {
     ScopedKernelLock lock(this);
     GetMetaHandlesOfType(lock, trans, type, &metahandles);
-    std::vector<int64>::const_iterator iter = metahandles.begin();
-    const std::vector<int64>::const_iterator end = metahandles.end();
+    std::vector<int64_t>::const_iterator iter = metahandles.begin();
+    const std::vector<int64_t>::const_iterator end = metahandles.end();
     // For all of this type's entries...
     for (; iter != end; ++iter) {
       EntryKernel* entry = GetEntryByHandle(lock, *iter);
       DCHECK(entry);
       const sync_pb::AttachmentMetadata metadata =
           entry->ref(ATTACHMENT_METADATA);
       // for each of this entry's attachments...
       for (int i = 0; i < metadata.record_size(); ++i) {
         AttachmentId id =
             AttachmentId::CreateFromProto(metadata.record(i).id());
@@ skipping 32 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer