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

components/sync_bookmarks/bookmark_model_associator.cc

 // Copyright 2012 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/sync_bookmarks/bookmark_model_associator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/format_macros.h"
@@ skipping 63 matching lines @@
   explicit BookmarkNodeFinder(const BookmarkNode* parent_node);
 
   // Finds the bookmark node that matches the given url, title and folder
   // attribute. Returns the matching node if one exists; NULL otherwise.
   // If there are multiple matches then a node with ID matching |preferred_id|
   // is returned; otherwise the first matching node is returned.
   // If a matching node is found, it's removed for further matches.
   const BookmarkNode* FindBookmarkNode(const GURL& url,
                                        const std::string& title,
                                        bool is_folder,
-                                       int64 preferred_id);
+                                       int64_t preferred_id);
 
   // Returns true if |bookmark_node| matches the specified |url|,
   // |title|, and |is_folder| flags.
   static bool NodeMatches(const BookmarkNode* bookmark_node,
                           const GURL& url,
                           const std::string& title,
                           bool is_folder);
 
  private:
   // Maps bookmark node titles to instances, duplicates allowed.
@@ skipping 41 matching lines @@
     ConvertTitleToSyncInternalFormat(title, &title);
 
     child_nodes_.insert(std::make_pair(title, child_node));
   }
 }
 
 const BookmarkNode* BookmarkNodeFinder::FindBookmarkNode(
     const GURL& url,
     const std::string& title,
     bool is_folder,
-    int64 preferred_id) {
+    int64_t preferred_id) {
   const BookmarkNode* match = nullptr;
 
   // First lookup a range of bookmarks with the same title.
   std::string adjusted_title;
   ConvertTitleToSyncInternalFormat(title, &adjusted_title);
   BookmarkNodeRange range = child_nodes_.equal_range(adjusted_title);
   BookmarkNodeMap::iterator match_iter = range.second;
   for (BookmarkNodeMap::iterator iter = range.first;
        iter != range.second;
        ++iter) {
@@ skipping 50 matching lines @@
     syncer::SyncMergeResult* local_merge_result,
     syncer::SyncMergeResult* syncer_merge_result)
     : local_merge_result_(local_merge_result),
       syncer_merge_result_(syncer_merge_result),
       duplicate_count_(0),
       native_model_sync_state_(UNSET) {}
 
 BookmarkModelAssociator::Context::~Context() {
 }
 
-void BookmarkModelAssociator::Context::PushNode(int64 sync_id) {
+void BookmarkModelAssociator::Context::PushNode(int64_t sync_id) {
   dfs_stack_.push(sync_id);
 }
 
-bool BookmarkModelAssociator::Context::PopNode(int64* sync_id) {
+bool BookmarkModelAssociator::Context::PopNode(int64_t* sync_id) {
   if (dfs_stack_.empty()) {
     *sync_id = 0;
     return false;
   }
   *sync_id = dfs_stack_.top();
   dfs_stack_.pop();
   return true;
 }
 
 void BookmarkModelAssociator::Context::SetPreAssociationVersions(
-    int64 native_version,
-    int64 sync_version) {
+    int64_t native_version,
+    int64_t sync_version) {
   local_merge_result_->set_pre_association_version(native_version);
   syncer_merge_result_->set_pre_association_version(sync_version);
 }
 
 void BookmarkModelAssociator::Context::SetNumItemsBeforeAssociation(
     int local_num,
     int sync_num) {
   local_merge_result_->set_num_items_before_association(local_num);
   syncer_merge_result_->set_num_items_before_association(sync_num);
 }
@@ skipping 44 matching lines @@
     // This hash code already exists in the set.
     ++duplicate_count_;
   }
 }
 
 void BookmarkModelAssociator::Context::AddBookmarkRoot(
     const bookmarks::BookmarkNode* root) {
   bookmark_roots_.push_back(root);
 }
 
-int64 BookmarkModelAssociator::Context::GetSyncPreAssociationVersion() const {
+int64_t BookmarkModelAssociator::Context::GetSyncPreAssociationVersion() const {
   return syncer_merge_result_->pre_association_version();
 }
 
 void BookmarkModelAssociator::Context::MarkForVersionUpdate(
     const bookmarks::BookmarkNode* node) {
   bookmarks_for_version_update_.push_back(node);
 }
 
 BookmarkModelAssociator::BookmarkModelAssociator(
     BookmarkModel* bookmark_model,
@@ skipping 16 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 syncer::SyncError BookmarkModelAssociator::DisassociateModels() {
   id_map_.clear();
   id_map_inverse_.clear();
   dirty_associations_sync_ids_.clear();
   return syncer::SyncError();
 }
 
-int64 BookmarkModelAssociator::GetSyncIdFromChromeId(const int64& node_id) {
+int64_t BookmarkModelAssociator::GetSyncIdFromChromeId(const int64_t& node_id) {
   BookmarkIdToSyncIdMap::const_iterator iter = id_map_.find(node_id);
   return iter == id_map_.end() ? syncer::kInvalidId : iter->second;
 }
 
 const BookmarkNode* BookmarkModelAssociator::GetChromeNodeFromSyncId(
-    int64 sync_id) {
+    int64_t sync_id) {
   SyncIdToBookmarkNodeMap::const_iterator iter = id_map_inverse_.find(sync_id);
   return iter == id_map_inverse_.end() ? NULL : iter->second;
 }
 
 bool BookmarkModelAssociator::InitSyncNodeFromChromeId(
-    const int64& node_id,
+    const int64_t& node_id,
     syncer::BaseNode* sync_node) {
   DCHECK(sync_node);
-  int64 sync_id = GetSyncIdFromChromeId(node_id);
+  int64_t sync_id = GetSyncIdFromChromeId(node_id);
   if (sync_id == syncer::kInvalidId)
     return false;
   if (sync_node->InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK)
     return false;
   DCHECK(sync_node->GetId() == sync_id);
   return true;
 }
 
 void BookmarkModelAssociator::AddAssociation(const BookmarkNode* node,
-                                             int64 sync_id) {
+                                             int64_t sync_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  int64 node_id = node->id();
+  int64_t node_id = node->id();
   DCHECK_NE(sync_id, syncer::kInvalidId);
   DCHECK(id_map_.find(node_id) == id_map_.end());
   DCHECK(id_map_inverse_.find(sync_id) == id_map_inverse_.end());
   id_map_[node_id] = sync_id;
   id_map_inverse_[sync_id] = node;
 }
 
 void BookmarkModelAssociator::Associate(const BookmarkNode* node,
                                         const syncer::BaseNode& sync_node) {
   AddAssociation(node, sync_node.GetId());
 
   // The same check exists in PersistAssociations. However it is better to
   // do the check earlier to avoid the cost of decrypting nodes again
   // in PersistAssociations.
   if (node->id() != sync_node.GetExternalId()) {
     dirty_associations_sync_ids_.insert(sync_node.GetId());
     PostPersistAssociationsTask();
   }
 }
 
-void BookmarkModelAssociator::Disassociate(int64 sync_id) {
+void BookmarkModelAssociator::Disassociate(int64_t sync_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SyncIdToBookmarkNodeMap::iterator iter = id_map_inverse_.find(sync_id);
   if (iter == id_map_inverse_.end())
     return;
   id_map_.erase(iter->second->id());
   id_map_inverse_.erase(iter);
   dirty_associations_sync_ids_.erase(sync_id);
 }
 
 bool BookmarkModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) {
@@ skipping 27 matching lines @@
       other_bookmarks_node.HasChildren() ||
       (has_mobile_folder && mobile_bookmarks_node.HasChildren());
   return true;
 }
 
 bool BookmarkModelAssociator::AssociateTaggedPermanentNode(
     syncer::BaseTransaction* trans,
     const BookmarkNode* permanent_node,
     const std::string& tag) {
   // Do nothing if |permanent_node| is already initialized and associated.
-  int64 sync_id = GetSyncIdFromChromeId(permanent_node->id());
+  int64_t sync_id = GetSyncIdFromChromeId(permanent_node->id());
   if (sync_id != syncer::kInvalidId)
     return true;
 
   syncer::ReadNode sync_node(trans);
   if (sync_node.InitByTagLookupForBookmarks(tag) != syncer::BaseNode::INIT_OK)
     return false;
 
   Associate(permanent_node, sync_node);
   return true;
 }
@@ skipping 47 matching lines @@
 
   if (!AssociateTaggedPermanentNode(trans, bookmark_model_->mobile_node(),
                                     kMobileBookmarksTag) &&
       expect_mobile_bookmarks_folder_) {
     return unrecoverable_error_handler_->CreateAndUploadError(
         FROM_HERE, "Mobile bookmarks node not found", model_type());
   }
 
   // Note: the root node may have additional extra nodes. Currently none of
   // them are meant to sync.
-  int64 bookmark_bar_sync_id =
+  int64_t bookmark_bar_sync_id =
       GetSyncIdFromChromeId(bookmark_model_->bookmark_bar_node()->id());
   DCHECK_NE(bookmark_bar_sync_id, syncer::kInvalidId);
   context->AddBookmarkRoot(bookmark_model_->bookmark_bar_node());
-  int64 other_bookmarks_sync_id =
+  int64_t other_bookmarks_sync_id =
       GetSyncIdFromChromeId(bookmark_model_->other_node()->id());
   DCHECK_NE(other_bookmarks_sync_id, syncer::kInvalidId);
   context->AddBookmarkRoot(bookmark_model_->other_node());
-  int64 mobile_bookmarks_sync_id =
+  int64_t mobile_bookmarks_sync_id =
       GetSyncIdFromChromeId(bookmark_model_->mobile_node()->id());
   if (expect_mobile_bookmarks_folder_)
     DCHECK_NE(syncer::kInvalidId, mobile_bookmarks_sync_id);
   if (mobile_bookmarks_sync_id != syncer::kInvalidId)
     context->AddBookmarkRoot(bookmark_model_->mobile_node());
 
   // WARNING: The order in which we push these should match their order in the
   // bookmark model (see BookmarkModel::DoneLoading(..)).
   context->PushNode(bookmark_bar_sync_id);
   context->PushNode(other_bookmarks_sync_id);
@@ skipping 44 matching lines @@
   }
   context->SetNumItemsAfterAssociation(
       bookmark_model_->root_node()->GetTotalNodeCount(), syncer_num);
 }
 
 syncer::SyncError BookmarkModelAssociator::BuildAssociations(Context* context) {
   DCHECK(bookmark_model_->loaded());
   DCHECK_NE(context->native_model_sync_state(), AHEAD);
 
   int initial_duplicate_count = 0;
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     syncer::WriteTransaction trans(FROM_HERE, user_share_, &new_version);
 
     syncer::SyncError error = AssociatePermanentFolders(&trans, context);
     if (error.IsSet())
       return error;
 
     SetNumItemsBeforeAssociation(&trans, context);
     initial_duplicate_count = context->duplicate_count();
 
@@ skipping 11 matching lines @@
     //   position as the corresponding sync node.
     //   If a matching node is found, update the properties of it from the
     //   corresponding sync node.
     // * When all children sync nodes are done, add the extra children bookmark
     //   nodes to the sync parent node.
     //
     // The best match algorithm uses folder title or bookmark title/url to
     // perform the primary match. If there are multiple match candidates it
     // selects the preferred one based on sync node external ID match to the
     // bookmark folder ID.
-    int64 sync_parent_id;
+    int64_t sync_parent_id;
     while (context->PopNode(&sync_parent_id)) {
       syncer::ReadNode sync_parent(&trans);
       if (sync_parent.InitByIdLookup(sync_parent_id) !=
           syncer::BaseNode::INIT_OK) {
         return unrecoverable_error_handler_->CreateAndUploadError(
             FROM_HERE, "Failed to lookup node.", model_type());
       }
       // Only folder nodes are pushed on to the stack.
       DCHECK(sync_parent.GetIsFolder());
 
       const BookmarkNode* parent_node = GetChromeNodeFromSyncId(sync_parent_id);
       if (!parent_node) {
         return unrecoverable_error_handler_->CreateAndUploadError(
             FROM_HERE, "Failed to find bookmark node for sync id.",
             model_type());
       }
       DCHECK(parent_node->is_folder());
 
-      std::vector<int64> children;
+      std::vector<int64_t> children;
       sync_parent.GetChildIds(&children);
 
       error = BuildAssociations(&trans, parent_node, children, context);
       if (error.IsSet())
         return error;
     }
 
     SetNumItemsAfterAssociation(&trans, context);
   }
 
@@ skipping 21 matching lines @@
                               context->native_model_sync_state(),
                               NATIVE_MODEL_SYNC_STATE_COUNT);
   }
 
   return syncer::SyncError();
 }
 
 syncer::SyncError BookmarkModelAssociator::BuildAssociations(
     syncer::WriteTransaction* trans,
     const BookmarkNode* parent_node,
-    const std::vector<int64>& sync_ids,
+    const std::vector<int64_t>& sync_ids,
     Context* context) {
   BookmarkNodeFinder node_finder(parent_node);
 
   int index = 0;
-  for (std::vector<int64>::const_iterator it = sync_ids.begin();
+  for (std::vector<int64_t>::const_iterator it = sync_ids.begin();
        it != sync_ids.end(); ++it) {
-    int64 sync_child_id = *it;
+    int64_t sync_child_id = *it;
     syncer::ReadNode sync_child_node(trans);
     if (sync_child_node.InitByIdLookup(sync_child_id) !=
         syncer::BaseNode::INIT_OK) {
       return unrecoverable_error_handler_->CreateAndUploadError(
           FROM_HERE, "Failed to lookup node.", model_type());
     }
 
-    int64 external_id = sync_child_node.GetExternalId();
+    int64_t external_id = sync_child_node.GetExternalId();
     GURL url(sync_child_node.GetBookmarkSpecifics().url());
     const BookmarkNode* child_node = node_finder.FindBookmarkNode(
         url, sync_child_node.GetTitle(), sync_child_node.GetIsFolder(),
         external_id);
     if (child_node) {
       // Skip local node update if the local model version matches and
       // the node is already associated and in the right position.
       bool is_in_sync = (context->native_model_sync_state() == IN_SYNC) &&
                         (child_node->id() == external_id) &&
                         (index < parent_node->child_count()) &&
@@ skipping 27 matching lines @@
       context->PushNode(sync_child_id);
     ++index;
   }
 
   // At this point all the children nodes of the parent sync node have
   // corresponding children in the parent bookmark node and they are all in
   // the right positions: from 0 to index - 1.
   // So the children starting from index in the parent bookmark node are the
   // ones that are not present in the parent sync node. So create them.
   for (int i = index; i < parent_node->child_count(); ++i) {
-    int64 sync_child_id = BookmarkChangeProcessor::CreateSyncNode(
+    int64_t sync_child_id = BookmarkChangeProcessor::CreateSyncNode(
         parent_node, bookmark_model_, i, trans, this,
         unrecoverable_error_handler_);
     if (syncer::kInvalidId == sync_child_id) {
       return unrecoverable_error_handler_->CreateAndUploadError(
           FROM_HERE, "Failed to create sync node.", model_type());
     }
 
     context->IncrementSyncItemsAdded();
     const BookmarkNode* child_node = parent_node->GetChild(i);
     context->MarkForVersionUpdate(child_node);
@@ skipping 37 matching lines @@
         model_type());
     return nullptr;
   }
 
   context->UpdateDuplicateCount(bookmark_title, url);
   return child_node;
 }
 
 int BookmarkModelAssociator::RemoveSyncNodeHierarchy(
     syncer::WriteTransaction* trans,
-    int64 sync_id) {
+    int64_t sync_id) {
   syncer::WriteNode sync_node(trans);
   if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
                             "Could not lookup bookmark node for ID deletion.",
                             syncer::BOOKMARKS);
     unrecoverable_error_handler_->OnSingleDataTypeUnrecoverableError(error);
     return 0;
   }
 
   return BookmarkChangeProcessor::RemoveSyncNodeHierarchy(trans, &sync_node,
                                                           this);
 }
 
 struct FolderInfo {
-  FolderInfo(const BookmarkNode* f, const BookmarkNode* p, int64 id)
+  FolderInfo(const BookmarkNode* f, const BookmarkNode* p, int64_t id)
       : folder(f), parent(p), sync_id(id) {}
   const BookmarkNode* folder;
   const BookmarkNode* parent;
-  int64 sync_id;
+  int64_t sync_id;
 };
 typedef std::vector<FolderInfo> FolderInfoList;
 
 void BookmarkModelAssociator::ApplyDeletesFromSyncJournal(
     syncer::BaseTransaction* trans,
     Context* context) {
   syncer::BookmarkDeleteJournalList bk_delete_journals;
   syncer::DeleteJournal::GetBookmarkDeleteJournals(trans, &bk_delete_journals);
   if (bk_delete_journals.empty())
     return;
 
   size_t num_journals_unmatched = bk_delete_journals.size();
 
   // Make a set of all external IDs in the delete journal,
   // ignore entries with unset external IDs.
-  std::set<int64> journaled_external_ids;
+  std::set<int64_t> journaled_external_ids;
   for (size_t i = 0; i < num_journals_unmatched; i++) {
     if (bk_delete_journals[i].external_id != 0)
       journaled_external_ids.insert(bk_delete_journals[i].external_id);
   }
 
   // Check bookmark model from top to bottom.
   BookmarkStack dfs_stack;
   for (BookmarkList::const_iterator it = context->bookmark_roots().begin();
        it != context->bookmark_roots().end(); ++it) {
     dfs_stack.push(*it);
@@ skipping 49 matching lines @@
           bk_delete_journals[journal_index] =
               bk_delete_journals[--num_journals_unmatched];
           break;
         }
       }
     }
   }
 
   // Ids of sync nodes not found in bookmark model, meaning the deletions are
   // persisted and correponding delete journals can be dropped.
-  std::set<int64> journals_to_purge;
+  std::set<int64_t> journals_to_purge;
 
   // Remove empty folders from bottom to top.
   for (FolderInfoList::reverse_iterator it = folders_matched.rbegin();
       it != folders_matched.rend(); ++it) {
     if (it->folder->child_count() == 0) {
       bookmark_model_->Remove(it->folder);
       context->IncrementLocalItemsDeleted();
     } else {
       // Keep non-empty folder and remove its journal so that it won't match
       // again in the future.
@@ skipping 19 matching lines @@
 void BookmarkModelAssociator::PersistAssociations() {
   // If there are no dirty associations we have nothing to do. We handle this
   // explicity instead of letting the for loop do it to avoid creating a write
   // transaction in this case.
   if (dirty_associations_sync_ids_.empty()) {
     DCHECK(id_map_.empty());
     DCHECK(id_map_inverse_.empty());
     return;
   }
 
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   std::vector<const BookmarkNode*> bnodes;
   {
     syncer::WriteTransaction trans(FROM_HERE, user_share_, &new_version);
     DirtyAssociationsSyncIds::iterator iter;
     for (iter = dirty_associations_sync_ids_.begin();
          iter != dirty_associations_sync_ids_.end();
          ++iter) {
-      int64 sync_id = *iter;
+      int64_t sync_id = *iter;
       syncer::WriteNode sync_node(&trans);
       if (sync_node.InitByIdLookup(sync_id) != syncer::BaseNode::INIT_OK) {
         syncer::SyncError error(
             FROM_HERE,
             syncer::SyncError::DATATYPE_ERROR,
             "Could not lookup bookmark node for ID persistence.",
             syncer::BOOKMARKS);
         unrecoverable_error_handler_->OnSingleDataTypeUnrecoverableError(error);
         return;
       }
@@ skipping 15 matching lines @@
   // We only access the cryptographer while holding a transaction.
   syncer::ReadTransaction trans(FROM_HERE, user_share_);
   const syncer::ModelTypeSet encrypted_types = trans.GetEncryptedTypes();
   return !encrypted_types.Has(syncer::BOOKMARKS) ||
       trans.GetCryptographer()->is_ready();
 }
 
 syncer::SyncError BookmarkModelAssociator::CheckModelSyncState(
     Context* context) const {
   DCHECK_EQ(context->native_model_sync_state(), UNSET);
-  int64 native_version =
+  int64_t native_version =
       bookmark_model_->root_node()->sync_transaction_version();
 
   syncer::ReadTransaction trans(FROM_HERE, user_share_);
-  int64 sync_version = trans.GetModelVersion(syncer::BOOKMARKS);
+  int64_t sync_version = trans.GetModelVersion(syncer::BOOKMARKS);
   context->SetPreAssociationVersions(native_version, sync_version);
 
   if (native_version != syncer::syncable::kInvalidTransactionVersion) {
     if (native_version == sync_version) {
       context->set_native_model_sync_state(IN_SYNC);
     } else {
       UMA_HISTOGRAM_ENUMERATION("Sync.LocalModelOutOfSync",
                                 ModelTypeToHistogramInt(syncer::BOOKMARKS),
                                 syncer::MODEL_TYPE_COUNT);
 
@@ skipping 17 matching lines @@
                                  syncer::BOOKMARKS);
       } else {
         context->set_native_model_sync_state(BEHIND);
       }
     }
   }
   return syncer::SyncError();
 }
 
 }  // namespace browser_sync