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

components/sync_bookmarks/bookmark_change_processor.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_change_processor.h"
 
+#include <stddef.h>
+
 #include <map>
 #include <stack>
 #include <vector>
 
 #include "base/location.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_client.h"
@@ skipping 99 matching lines @@
     BookmarkModelAssociator* associator) {
   // Remove children.
   int num_removed = RemoveAllChildNodes(trans, sync_node->GetId(), associator);
   // Remove the node itself.
   RemoveOneSyncNode(sync_node, associator);
   return num_removed + 1;
 }
 
 void BookmarkChangeProcessor::RemoveSyncNodeHierarchy(
     const BookmarkNode* topmost) {
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
     syncer::WriteNode topmost_sync_node(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(topmost->id(),
                                                      &topmost_sync_node)) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to init sync node from chrome node",
                               syncer::BOOKMARKS);
       error_handler()->OnSingleDataTypeUnrecoverableError(error);
       return;
     }
     RemoveSyncNodeHierarchy(&trans, &topmost_sync_node, model_associator_);
   }
 
   // Don't need to update versions of deleted nodes.
   UpdateTransactionVersion(new_version, bookmark_model_,
                            std::vector<const BookmarkNode*>());
 }
 
 void BookmarkChangeProcessor::RemoveAllSyncNodes() {
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
 
-    int64 bookmark_bar_node_sync_id = model_associator_->GetSyncIdFromChromeId(
-        bookmark_model_->bookmark_bar_node()->id());
+    int64_t bookmark_bar_node_sync_id =
+        model_associator_->GetSyncIdFromChromeId(
+            bookmark_model_->bookmark_bar_node()->id());
     DCHECK_NE(syncer::kInvalidId, bookmark_bar_node_sync_id);
     RemoveAllChildNodes(&trans, bookmark_bar_node_sync_id, model_associator_);
 
-    int64 other_node_sync_id = model_associator_->GetSyncIdFromChromeId(
+    int64_t other_node_sync_id = model_associator_->GetSyncIdFromChromeId(
         bookmark_model_->other_node()->id());
     DCHECK_NE(syncer::kInvalidId, other_node_sync_id);
     RemoveAllChildNodes(&trans, other_node_sync_id, model_associator_);
 
     // Remove mobile bookmarks node only if it is present.
-    int64 mobile_node_sync_id = model_associator_->GetSyncIdFromChromeId(
+    int64_t mobile_node_sync_id = model_associator_->GetSyncIdFromChromeId(
         bookmark_model_->mobile_node()->id());
     if (mobile_node_sync_id != syncer::kInvalidId) {
       RemoveAllChildNodes(&trans, mobile_node_sync_id, model_associator_);
     }
 
     // Note: the root node may have additional extra nodes. Currently none of
     // them are meant to sync.
   }
 
   // Don't need to update versions of deleted nodes.
   UpdateTransactionVersion(new_version, bookmark_model_,
                            std::vector<const BookmarkNode*>());
 }
 
 // static
 int BookmarkChangeProcessor::RemoveAllChildNodes(
     syncer::WriteTransaction* trans,
-    int64 topmost_sync_id,
+    int64_t topmost_sync_id,
     BookmarkModelAssociator* associator) {
   // Do a DFS and delete all the child sync nodes, use sync id instead of
   // bookmark node ids since the bookmark nodes may already be deleted.
   // The equivalent recursive version of this iterative DFS:
   // remove_all_children(node_id, topmost_node_id):
   //    node.initByIdLookup(node_id)
   //    while(node.GetFirstChildId() != syncer::kInvalidId)
   //      remove_all_children(node.GetFirstChildId(), topmost_node_id)
   //    if(node_id != topmost_node_id)
   //      delete node
 
   int num_removed = 0;
-  std::stack<int64> dfs_sync_id_stack;
+  std::stack<int64_t> dfs_sync_id_stack;
   // Push the topmost node.
   dfs_sync_id_stack.push(topmost_sync_id);
   while (!dfs_sync_id_stack.empty()) {
-    const int64 sync_node_id = dfs_sync_id_stack.top();
+    const int64_t sync_node_id = dfs_sync_id_stack.top();
     syncer::WriteNode node(trans);
     node.InitByIdLookup(sync_node_id);
     if (!node.GetIsFolder() || node.GetFirstChildId() == syncer::kInvalidId) {
       // All children of the node has been processed, delete the node and
       // pop it off the stack.
       dfs_sync_id_stack.pop();
       // Do not delete the topmost node.
       if (sync_node_id != topmost_sync_id) {
         RemoveOneSyncNode(&node, associator);
         num_removed++;
       } else {
         // if we are processing topmost node, all other nodes must be processed
         // the stack should be empty.
         DCHECK(dfs_sync_id_stack.empty());
       }
     } else {
-      int64 child_id = node.GetFirstChildId();
+      int64_t child_id = node.GetFirstChildId();
       if (child_id != syncer::kInvalidId) {
         dfs_sync_id_stack.push(child_id);
       }
     }
   }
   return num_removed;
 }
 
 // static
 void BookmarkChangeProcessor::RemoveOneSyncNode(
     syncer::WriteNode* sync_node,
     BookmarkModelAssociator* associator) {
   // This node should have no children.
   DCHECK(!sync_node->HasChildren());
   // Remove association and delete the sync node.
   associator->Disassociate(sync_node->GetId());
   sync_node->Tombstone();
 }
 
 void BookmarkChangeProcessor::CreateOrUpdateSyncNode(const BookmarkNode* node) {
   if (!CanSyncNode(node)) {
     NOTREACHED();
     return;
   }
 
   const BookmarkNode* parent = node->parent();
   int index = node->parent()->GetIndexOf(node);
 
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
-  int64 sync_id = syncer::kInvalidId;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t sync_id = syncer::kInvalidId;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
     sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
     if (sync_id != syncer::kInvalidId) {
       UpdateSyncNode(
           node, bookmark_model_, &trans, model_associator_, error_handler());
     } else {
       sync_id = CreateSyncNode(parent,
                                bookmark_model_,
@@ skipping 29 matching lines @@
 void BookmarkChangeProcessor::BookmarkNodeAdded(BookmarkModel* model,
                                                 const BookmarkNode* parent,
                                                 int index) {
   DCHECK(share_handle());
   const BookmarkNode* node = parent->GetChild(index);
   if (CanSyncNode(node))
     CreateOrUpdateSyncNode(node);
 }
 
 // static
-int64 BookmarkChangeProcessor::CreateSyncNode(const BookmarkNode* parent,
-    BookmarkModel* model, int index, syncer::WriteTransaction* trans,
+int64_t BookmarkChangeProcessor::CreateSyncNode(
+    const BookmarkNode* parent,
+    BookmarkModel* model,
+    int index,
+    syncer::WriteTransaction* trans,
     BookmarkModelAssociator* associator,
     sync_driver::DataTypeErrorHandler* error_handler) {
   const BookmarkNode* child = parent->GetChild(index);
   DCHECK(child);
 
   // Create a WriteNode container to hold the new node.
   syncer::WriteNode sync_child(trans);
 
   // Actually create the node with the appropriate initial position.
   if (!PlaceSyncNode(CREATE, parent, index, trans, &sync_child, associator)) {
@@ skipping 43 matching lines @@
     return;
   // We shouldn't see changes to the top-level nodes.
   if (model->is_permanent_node(node)) {
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
   CreateOrUpdateSyncNode(node);
 }
 
 // Static.
-int64 BookmarkChangeProcessor::UpdateSyncNode(
+int64_t BookmarkChangeProcessor::UpdateSyncNode(
     const BookmarkNode* node,
     BookmarkModel* model,
     syncer::WriteTransaction* trans,
     BookmarkModelAssociator* associator,
     sync_driver::DataTypeErrorHandler* error_handler) {
   // Lookup the sync node that's associated with |node|.
   syncer::WriteNode sync_node(trans);
   if (!associator->InitSyncNodeFromChromeId(node->id(), &sync_node)) {
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
@@ skipping 22 matching lines @@
 
   if (!CanSyncNode(child))
     return;
 
   // We shouldn't see changes to the top-level nodes.
   if (model->is_permanent_node(child)) {
     NOTREACHED() << "Saw update to permanent node!";
     return;
   }
 
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
 
     // Lookup the sync node that's associated with |child|.
     syncer::WriteNode sync_node(&trans);
     if (!model_associator_->InitSyncNodeFromChromeId(child->id(), &sync_node)) {
       syncer::SyncError error(FROM_HERE,
                               syncer::SyncError::DATATYPE_ERROR,
                               "Failed to init sync node from chrome node",
@@ skipping 37 matching lines @@
     return;
   }
 
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkChangeProcessor::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
   if (!CanSyncNode(node))
     return;
-  int64 new_version = syncer::syncable::kInvalidTransactionVersion;
+  int64_t new_version = syncer::syncable::kInvalidTransactionVersion;
   std::vector<const BookmarkNode*> children;
   {
     // Acquire a scoped write lock via a transaction.
     syncer::WriteTransaction trans(FROM_HERE, share_handle(), &new_version);
 
     // The given node's children got reordered. We need to reorder all the
     // children of the corresponding sync node.
     for (int i = 0; i < node->child_count(); ++i) {
       const BookmarkNode* child = node->GetChild(i);
       children.push_back(child);
@@ skipping 66 matching lines @@
     }
   }
   return success;
 }
 
 // ApplyModelChanges is called by the sync backend after changes have been made
 // to the sync engine's model.  Apply these changes to the browser bookmark
 // model.
 void BookmarkChangeProcessor::ApplyChangesFromSyncModel(
     const syncer::BaseTransaction* trans,
-    int64 model_version,
+    int64_t model_version,
     const syncer::ImmutableChangeRecordList& changes) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // A note about ordering.  Sync backend is responsible for ordering the change
   // records in the following order:
   //
   // 1. Deletions, from leaves up to parents.
   // 2. Existing items with synced parents & predecessors.
   // 3. New items with synced parents & predecessors.
   // 4. Items with parents & predecessors in the list.
   // 5. Repeat #4 until all items are in the list.
@@ skipping 71 matching lines @@
     const BookmarkNode* parent = dst->parent();
     int index = parent->GetIndexOf(dst);
     if (index > -1)
       model->Remove(parent->GetChild(index));
   }
 
   // A map to keep track of some reordering work we defer until later.
   std::multimap<int, const BookmarkNode*> to_reposition;
 
   syncer::ReadNode synced_bookmarks(trans);
-  int64 synced_bookmarks_id = syncer::kInvalidId;
+  int64_t synced_bookmarks_id = syncer::kInvalidId;
   if (synced_bookmarks.InitByTagLookupForBookmarks(kMobileBookmarksTag) ==
       syncer::BaseNode::INIT_OK) {
     synced_bookmarks_id = synced_bookmarks.GetId();
   }
 
   // Continue iterating where the previous loop left off.
   for ( ; it != changes.Get().end(); ++it) {
     const BookmarkNode* dst =
         model_associator_->GetChromeNodeFromSyncId(it->id);
 
@@ skipping 113 matching lines @@
     model->SetDateAdded(
         node,
         base::Time::FromInternalValue(specifics.creation_time_us()));
   }
   SetBookmarkFavicon(&sync_node, node, model, sync_client);
   model->SetNodeMetaInfoMap(node, *GetBookmarkMetaInfo(&sync_node));
 }
 
 // static
 void BookmarkChangeProcessor::UpdateTransactionVersion(
-    int64 new_version,
+    int64_t new_version,
     BookmarkModel* model,
     const std::vector<const BookmarkNode*>& nodes) {
   if (new_version != syncer::syncable::kInvalidTransactionVersion) {
     model->SetNodeSyncTransactionVersion(model->root_node(), new_version);
     for (size_t i = 0; i < nodes.size(); ++i) {
       model->SetNodeSyncTransactionVersion(nodes[i], new_version);
     }
   }
 }
 
@@ skipping 25 matching lines @@
   DCHECK(parent);
 
   const BookmarkNode* node;
   if (sync_node->GetIsFolder()) {
     node = model->AddFolderWithMetaInfo(parent, index, title,
                                         GetBookmarkMetaInfo(sync_node).get());
   } else {
     // 'creation_time_us' was added in m24. Assume a time of 0 means now.
     const sync_pb::BookmarkSpecifics& specifics =
         sync_node->GetBookmarkSpecifics();
-    const int64 create_time_internal = specifics.creation_time_us();
+    const int64_t create_time_internal = specifics.creation_time_us();
     base::Time create_time = (create_time_internal == 0) ?
         base::Time::Now() : base::Time::FromInternalValue(create_time_internal);
     node = model->AddURLWithCreationTimeAndMetaInfo(
         parent, index, title, url, create_time,
         GetBookmarkMetaInfo(sync_node).get());
     if (node)
       SetBookmarkFavicon(sync_node, node, model, sync_client);
   }
 
   return node;
@@ skipping 129 matching lines @@
     updated_specifics.set_icon_url(bookmark_node->icon_url().spec());
     sync_node->SetBookmarkSpecifics(updated_specifics);
   }
 }
 
 bool BookmarkChangeProcessor::CanSyncNode(const BookmarkNode* node) {
   return bookmark_model_->client()->CanSyncNode(node);
 }
 
 }  // namespace browser_sync