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

chrome/browser/sync/profile_sync_service_bookmark_unittest.cc

 // Copyright (c) 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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <queue>
 #include <stack>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/base_bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_model.h"
@@ skipping 43 matching lines @@
 void MakeServerUpdate(syncer::WriteTransaction* trans,
                       syncer::WriteNode* node) {
   syncer::syncable::ChangeEntryIDAndUpdateChildren(
       trans->GetWrappedWriteTrans(), node->GetMutableEntryForTest(),
       syncer::syncable::Id::CreateFromServerId(
           base::Int64ToString(node->GetId())));
   node->GetMutableEntryForTest()->PutBaseVersion(10);
   node->GetMutableEntryForTest()->PutIsUnappliedUpdate(true);
 }
 
-void MakeServerUpdate(syncer::WriteTransaction* trans, int64 id) {
+void MakeServerUpdate(syncer::WriteTransaction* trans, int64_t id) {
   syncer::WriteNode node(trans);
   EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
   MakeServerUpdate(trans, &node);
 }
 
 class TestSyncClient : public sync_driver::FakeSyncClient {
  public:
   explicit TestSyncClient(Profile* profile) : profile_(profile) {}
 
   bookmarks::BookmarkModel* GetBookmarkModel() override {
@@ skipping 19 matching lines @@
 // syncer::SyncObserver (i.e., the ProfileSyncService) to test the client
 // change-application behavior.
 // Tests using FakeServerChange should be careful to avoid back-references,
 // since FakeServerChange will send the edits in the order specified.
 class FakeServerChange {
  public:
   explicit FakeServerChange(syncer::WriteTransaction* trans) : trans_(trans) {
   }
 
   // Pretend that the server told the syncer to add a bookmark object.
-  int64 AddWithMetaInfo(const std::string& title,
-                        const std::string& url,
-                        const BookmarkNode::MetaInfoMap* meta_info_map,
-                        bool is_folder,
-                        int64 parent_id,
-                        int64 predecessor_id) {
+  int64_t AddWithMetaInfo(const std::string& title,
+                          const std::string& url,
+                          const BookmarkNode::MetaInfoMap* meta_info_map,
+                          bool is_folder,
+                          int64_t parent_id,
+                          int64_t predecessor_id) {
     syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
     syncer::WriteNode node(trans_);
     if (predecessor_id == 0) {
       EXPECT_TRUE(node.InitBookmarkByCreation(parent, NULL));
     } else {
       syncer::ReadNode predecessor(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
       EXPECT_TRUE(node.InitBookmarkByCreation(parent, &predecessor));
@@ skipping 12 matching lines @@
       SetNodeMetaInfo(*meta_info_map, &specifics);
     node.SetBookmarkSpecifics(specifics);
 
     syncer::ChangeRecord record;
     record.action = syncer::ChangeRecord::ACTION_ADD;
     record.id = node.GetId();
     changes_.push_back(record);
     return node.GetId();
   }
 
-  int64 Add(const std::string& title,
-            const std::string& url,
-            bool is_folder,
-            int64 parent_id,
-            int64 predecessor_id) {
+  int64_t Add(const std::string& title,
+              const std::string& url,
+              bool is_folder,
+              int64_t parent_id,
+              int64_t predecessor_id) {
     return AddWithMetaInfo(title, url, NULL, is_folder, parent_id,
                            predecessor_id);
   }
 
   // Add a bookmark folder.
-  int64 AddFolder(const std::string& title,
-                  int64 parent_id,
-                  int64 predecessor_id) {
+  int64_t AddFolder(const std::string& title,
+                    int64_t parent_id,
+                    int64_t predecessor_id) {
     return Add(title, std::string(), true, parent_id, predecessor_id);
   }
-  int64 AddFolderWithMetaInfo(const std::string& title,
-                              const BookmarkNode::MetaInfoMap* meta_info_map,
-                              int64 parent_id,
-                              int64 predecessor_id) {
+  int64_t AddFolderWithMetaInfo(const std::string& title,
+                                const BookmarkNode::MetaInfoMap* meta_info_map,
+                                int64_t parent_id,
+                                int64_t predecessor_id) {
     return AddWithMetaInfo(title, std::string(), meta_info_map, true, parent_id,
                            predecessor_id);
   }
 
   // Add a bookmark.
-  int64 AddURL(const std::string& title,
-               const std::string& url,
-               int64 parent_id,
-               int64 predecessor_id) {
+  int64_t AddURL(const std::string& title,
+                 const std::string& url,
+                 int64_t parent_id,
+                 int64_t predecessor_id) {
     return Add(title, url, false, parent_id, predecessor_id);
   }
-  int64 AddURLWithMetaInfo(const std::string& title,
-                           const std::string& url,
-                           const BookmarkNode::MetaInfoMap* meta_info_map,
-                           int64 parent_id,
-                           int64 predecessor_id) {
+  int64_t AddURLWithMetaInfo(const std::string& title,
+                             const std::string& url,
+                             const BookmarkNode::MetaInfoMap* meta_info_map,
+                             int64_t parent_id,
+                             int64_t predecessor_id) {
     return AddWithMetaInfo(title, url, meta_info_map, false, parent_id,
                            predecessor_id);
   }
 
   // Pretend that the server told the syncer to delete an object.
-  void Delete(int64 id) {
+  void Delete(int64_t id) {
     {
       // Delete the sync node.
       syncer::WriteNode node(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
       if (node.GetIsFolder())
         EXPECT_FALSE(node.GetFirstChildId());
       node.GetMutableEntryForTest()->PutServerIsDel(true);
       node.Tombstone();
     }
     {
       // Verify the deletion.
       syncer::ReadNode node(trans_);
       EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL, node.InitByIdLookup(id));
     }
 
     syncer::ChangeRecord record;
     record.action = syncer::ChangeRecord::ACTION_DELETE;
     record.id = id;
     // Deletions are always first in the changelist, but we can't actually do
     // WriteNode::Remove() on the node until its children are moved. So, as
     // a practical matter, users of FakeServerChange must move or delete
     // children before parents.  Thus, we must insert the deletion record
     // at the front of the vector.
     changes_.insert(changes_.begin(), record);
   }
 
   // Set a new title value, and return the old value.
-  std::string ModifyTitle(int64 id, const std::string& new_title) {
+  std::string ModifyTitle(int64_t id, const std::string& new_title) {
     syncer::WriteNode node(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     std::string old_title = node.GetTitle();
     node.SetTitle(new_title);
     SetModified(id);
     return old_title;
   }
 
   // Set a new parent and predecessor value.  Return the old parent id.
   // We could return the old predecessor id, but it turns out not to be
   // very useful for assertions.
-  int64 ModifyPosition(int64 id, int64 parent_id, int64 predecessor_id) {
+  int64_t ModifyPosition(int64_t id,
+                         int64_t parent_id,
+                         int64_t predecessor_id) {
     syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
     syncer::WriteNode node(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
-    int64 old_parent_id = node.GetParentId();
+    int64_t old_parent_id = node.GetParentId();
     if (predecessor_id == 0) {
       EXPECT_TRUE(node.SetPosition(parent, NULL));
     } else {
       syncer::ReadNode predecessor(trans_);
       EXPECT_EQ(BaseNode::INIT_OK, predecessor.InitByIdLookup(predecessor_id));
       EXPECT_EQ(predecessor.GetParentId(), parent.GetId());
       EXPECT_TRUE(node.SetPosition(parent, &predecessor));
     }
     SetModified(id);
     return old_parent_id;
   }
 
-  void ModifyCreationTime(int64 id, int64 creation_time_us) {
+  void ModifyCreationTime(int64_t id, int64_t creation_time_us) {
     syncer::WriteNode node(trans_);
     ASSERT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     sync_pb::BookmarkSpecifics specifics = node.GetBookmarkSpecifics();
     specifics.set_creation_time_us(creation_time_us);
     node.SetBookmarkSpecifics(specifics);
     SetModified(id);
   }
 
-  void ModifyMetaInfo(int64 id,
+  void ModifyMetaInfo(int64_t id,
                       const BookmarkNode::MetaInfoMap& meta_info_map) {
     syncer::WriteNode node(trans_);
     ASSERT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     sync_pb::BookmarkSpecifics specifics = node.GetBookmarkSpecifics();
     SetNodeMetaInfo(meta_info_map, &specifics);
     node.SetBookmarkSpecifics(specifics);
     SetModified(id);
   }
 
   // Pass the fake change list to |service|.
   void ApplyPendingChanges(sync_driver::ChangeProcessor* processor) {
     processor->ApplyChangesFromSyncModel(
         trans_, 0, syncer::ImmutableChangeRecordList(&changes_));
   }
 
   const syncer::ChangeRecordList& changes() {
     return changes_;
   }
 
  private:
   // Helper function to push an ACTION_UPDATE record onto the back
   // of the changelist.
-  void SetModified(int64 id) {
+  void SetModified(int64_t id) {
     // Coalesce multi-property edits.
     if (!changes_.empty() && changes_.back().id == id &&
         changes_.back().action ==
         syncer::ChangeRecord::ACTION_UPDATE)
       return;
     syncer::ChangeRecord record;
     record.action = syncer::ChangeRecord::ACTION_UPDATE;
     record.id = id;
     changes_.push_back(record);
   }
@@ skipping 91 matching lines @@
   }
 
   // Inserts a folder directly to the share.
   // Do not use this after model association is complete.
   //
   // This function differs from the AddFolder() function declared elsewhere in
   // this file in that it only affects the sync model.  It would be invalid to
   // change the sync model directly after ModelAssociation.  This function can
   // be invoked prior to model association to set up first-time sync model
   // association scenarios.
-  int64 AddFolderToShare(syncer::WriteTransaction* trans,
-                         const std::string& title) {
+  int64_t AddFolderToShare(syncer::WriteTransaction* trans,
+                           const std::string& title) {
     EXPECT_FALSE(model_associator_);
 
     // Be sure to call CreatePermanentBookmarkNodes(), otherwise this will fail.
     syncer::ReadNode bookmark_bar(trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               bookmark_bar.InitByTagLookupForBookmarks("bookmark_bar"));
 
     syncer::WriteNode node(trans);
     EXPECT_TRUE(node.InitBookmarkByCreation(bookmark_bar, NULL));
     node.SetIsFolder(true);
     node.SetTitle(title);
 
     return node.GetId();
   }
 
   // Inserts a bookmark directly to the share.
   // Do not use this after model association is complete.
   //
   // This function differs from the AddURL() function declared elsewhere in this
   // file in that it only affects the sync model.  It would be invalid to change
   // the sync model directly after ModelAssociation.  This function can be
   // invoked prior to model association to set up first-time sync model
   // association scenarios.
-  int64 AddBookmarkToShare(syncer::WriteTransaction* trans,
-                           int64 parent_id,
-                           const std::string& title,
-                           const std::string& url) {
+  int64_t AddBookmarkToShare(syncer::WriteTransaction* trans,
+                             int64_t parent_id,
+                             const std::string& title,
+                             const std::string& url) {
     EXPECT_FALSE(model_associator_);
 
     syncer::ReadNode parent(trans);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
 
     sync_pb::BookmarkSpecifics specifics;
     specifics.set_url(url);
     specifics.set_title(title);
 
     syncer::WriteNode node(trans);
@@ skipping 57 matching lines @@
       "other_bookmarks",
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
       "synced_bookmarks",
 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
     };
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     syncer::ReadNode root(&trans);
     EXPECT_EQ(BaseNode::INIT_OK, root.InitTypeRoot(type));
 
     // Loop through creating permanent nodes as necessary.
-    int64 last_child_id = syncer::kInvalidId;
+    int64_t last_child_id = syncer::kInvalidId;
     for (int i = 0; i < kNumPermanentNodes; ++i) {
       // First check if the node already exists. This is for tests that involve
       // persistence and set up sync more than once.
       syncer::ReadNode lookup(&trans);
       if (lookup.InitByTagLookupForBookmarks(permanent_tags[i]) ==
           syncer::ReadNode::INIT_OK) {
         last_child_id = lookup.GetId();
         continue;
       }
 
@@ skipping 163 matching lines @@
     if (!bnode->empty())
       EXPECT_TRUE(gnode.GetFirstChildId());
   }
 
   void ExpectSyncerNodeMatching(const BookmarkNode* bnode) {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectSyncerNodeMatching(&trans, bnode);
   }
 
   void ExpectBrowserNodeMatching(syncer::BaseTransaction* trans,
-                                 int64 sync_id) {
+                                 int64_t sync_id) {
     EXPECT_TRUE(sync_id);
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     ASSERT_TRUE(CanSyncNode(bnode));
 
-    int64 id = model_associator_->GetSyncIdFromChromeId(bnode->id());
+    int64_t id = model_associator_->GetSyncIdFromChromeId(bnode->id());
     EXPECT_EQ(id, sync_id);
     ExpectSyncerNodeMatching(trans, bnode);
   }
 
-  void ExpectBrowserNodeUnknown(int64 sync_id) {
+  void ExpectBrowserNodeUnknown(int64_t sync_id) {
     EXPECT_FALSE(model_associator_->GetChromeNodeFromSyncId(sync_id));
   }
 
-  void ExpectBrowserNodeKnown(int64 sync_id) {
+  void ExpectBrowserNodeKnown(int64_t sync_id) {
     EXPECT_TRUE(model_associator_->GetChromeNodeFromSyncId(sync_id));
   }
 
   void ExpectSyncerNodeKnown(const BookmarkNode* node) {
-    int64 sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
+    int64_t sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
     EXPECT_NE(sync_id, syncer::kInvalidId);
   }
 
   void ExpectSyncerNodeUnknown(const BookmarkNode* node) {
-    int64 sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
+    int64_t sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
     EXPECT_EQ(sync_id, syncer::kInvalidId);
   }
 
-  void ExpectBrowserNodeTitle(int64 sync_id, const std::string& title) {
+  void ExpectBrowserNodeTitle(int64_t sync_id, const std::string& title) {
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     EXPECT_EQ(bnode->GetTitle(), base::UTF8ToUTF16(title));
   }
 
-  void ExpectBrowserNodeURL(int64 sync_id, const std::string& url) {
+  void ExpectBrowserNodeURL(int64_t sync_id, const std::string& url) {
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     EXPECT_EQ(GURL(url), bnode->url());
   }
 
-  void ExpectBrowserNodeParent(int64 sync_id, int64 parent_sync_id) {
+  void ExpectBrowserNodeParent(int64_t sync_id, int64_t parent_sync_id) {
     const BookmarkNode* node =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(node);
     const BookmarkNode* parent =
         model_associator_->GetChromeNodeFromSyncId(parent_sync_id);
     EXPECT_TRUE(parent);
     EXPECT_EQ(node->parent(), parent);
   }
 
   void ExpectModelMatch(syncer::BaseTransaction* trans) {
     const BookmarkNode* root = model_->root_node();
 #if defined(OS_IOS) || defined(OS_ANDROID)
     EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 1);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 2);
 #else
     EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 1);
     EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 2);
 #endif  // defined(OS_IOS) || defined(OS_ANDROID)
 
-    std::stack<int64> stack;
+    std::stack<int64_t> stack;
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
-      int64 id = stack.top();
+      int64_t id = stack.top();
       stack.pop();
       if (!id) continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
       syncer::ReadNode gnode(trans);
       ASSERT_EQ(BaseNode::INIT_OK, gnode.InitByIdLookup(id));
       stack.push(gnode.GetSuccessorId());
       if (gnode.GetIsFolder())
         stack.push(gnode.GetFirstChildId());
     }
   }
 
   void ExpectModelMatch() {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
-  int64 mobile_bookmarks_id() {
+  int64_t mobile_bookmarks_id() {
     return
         model_associator_->GetSyncIdFromChromeId(model_->mobile_node()->id());
   }
 
-  int64 other_bookmarks_id() {
+  int64_t other_bookmarks_id() {
     return
         model_associator_->GetSyncIdFromChromeId(model_->other_node()->id());
   }
 
-  int64 bookmark_bar_id() {
+  int64_t bookmark_bar_id() {
     return model_associator_->GetSyncIdFromChromeId(
         model_->bookmark_bar_node()->id());
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 
  protected:
   TestingProfile profile_;
   TestSyncClient sync_client_;
@@ skipping 30 matching lines @@
 // association code.
 TEST_F(ProfileSyncServiceBookmarkTest, InitialModelAssociate) {
   const int kNumBookmarksPerFolder = 10;
   const int kNumFolders = 10;
 
   CreatePermanentBookmarkNodes();
 
   {
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     for (int i = 0; i < kNumFolders; ++i) {
-      int64 folder_id =
+      int64_t folder_id =
           AddFolderToShare(&trans, base::StringPrintf("folder%05d", i));
       for (int j = 0; j < kNumBookmarksPerFolder; ++j) {
         AddBookmarkToShare(
             &trans, folder_id, base::StringPrintf("bookmark%05d", j),
             base::StringPrintf("http://www.google.com/search?q=%05d", j));
       }
     }
   }
 
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
@@ skipping 25 matching lines @@
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   const BookmarkNode* folder = model_->AddFolder(model_->bookmark_bar_node(), 0,
                                                  base::ASCIIToUTF16("foobar"));
   const BookmarkNode* bookmark =
       model_->AddURL(folder, 0, base::ASCIIToUTF16("Airplanes"),
                      GURL("http://www.easyjet.com/"));
 
   CreatePermanentBookmarkNodes();
 
   // Create entries matching the folder and the bookmark above.
-  int64 folder_id, bookmark_id;
+  int64_t folder_id, bookmark_id;
   {
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     folder_id = AddFolderToShare(&trans, "foobar");
     bookmark_id = AddBookmarkToShare(&trans, folder_id, "Airplanes",
                                      "http://www.easyjet.com/");
   }
 
   // Associate the bookmark sync node with the native model one and make
   // it look like it was deleted by a server update.
   {
@@ skipping 20 matching lines @@
 // Also tests that the external ID is used to match the right bookmark
 // among multiple identical bookmarks when dealing with the delete journal.
 TEST_F(ProfileSyncServiceBookmarkTest,
        InitialModelAssociateVerifyExternalIdMatch) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   const int kNumFolders = 10;
   const int kNumBookmarks = 10;
   const int kFolderToIncludeBookmarks = 7;
   const int kBookmarkToDelete = 4;
 
-  int64 folder_ids[kNumFolders];
-  int64 bookmark_ids[kNumBookmarks];
+  int64_t folder_ids[kNumFolders];
+  int64_t bookmark_ids[kNumBookmarks];
 
   // Create native folders and bookmarks with identical names. Only
   // one of the folders contains bookmarks and others are empty. Here is the
   // expected tree shape:
   // Bookmarks bar
   // +- folder (#0)
   // +- folder (#1)
   // ...
   // +- folder (#7) <-- Only this folder contains bookmarks.
   //    +- bookmark (#0)
@@ skipping 20 matching lines @@
         model_->AddURL(parent_folder, i, base::ASCIIToUTF16("bookmark"),
                        GURL("http://www.google.com/"));
     bookmark_ids[i] = bookmark->id();
   }
 
   // Number of nodes in bookmark bar before association.
   int total_node_count = model_->bookmark_bar_node()->GetTotalNodeCount();
 
   CreatePermanentBookmarkNodes();
 
-  int64 sync_bookmark_id_to_delete = 0;
+  int64_t sync_bookmark_id_to_delete = 0;
   {
     // Create sync folders matching native folders above.
-    int64 parent_id = 0;
+    int64_t parent_id = 0;
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     // Create in reverse order because AddFolderToShare passes NULL for
     // |predecessor| argument.
     for (int i = kNumFolders - 1; i >= 0; i--) {
-      int64 id = AddFolderToShare(&trans, "folder");
+      int64_t id = AddFolderToShare(&trans, "folder");
 
       // Pre-map sync folders to native folders by setting
       // external ID. This will verify that the association algorithm picks
       // the right ones despite all of them having identical names.
       // More specifically this will help to avoid cloning bookmarks from
       // a wrong folder.
       syncer::WriteNode node(&trans);
       EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
       node.GetMutableEntryForTest()->PutLocalExternalId(folder_ids[i]);
 
@@ skipping 64 matching lines @@
   model_->AddURL(folder, 0, base::ASCIIToUTF16("node1"),
                  GURL("http://www.node1.com/"));
   model_->AddURL(folder, 1, base::ASCIIToUTF16("node2"),
                  GURL("http://www.node2.com/"));
 
   // On the sync side create a matching folder, one matching node, one
   // unmatching node, and one node with an invalid URL.
   CreatePermanentBookmarkNodes();
   {
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
-    int64 folder_id = AddFolderToShare(&trans, "folder");
+    int64_t folder_id = AddFolderToShare(&trans, "folder");
     // Please note that each AddBookmarkToShare inserts the node at the front
     // so the actual order of children in the directory will be opposite.
     AddBookmarkToShare(&trans, folder_id, "node2", "http://www.node2.com/");
     AddBookmarkToShare(&trans, folder_id, "node3", "");
     AddBookmarkToShare(&trans, folder_id, "node4", "http://www.node4.com/");
   }
 
   // Perform association.
   StartSync();
 
@@ skipping 70 matching lines @@
   ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeProcessing) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
   FakeServerChange adds(&trans);
-  int64 f1 = adds.AddFolder("Server Folder B", bookmark_bar_id(), 0);
-  int64 f2 = adds.AddFolder("Server Folder A", bookmark_bar_id(), f1);
-  int64 u1 = adds.AddURL("Some old site", "ftp://nifty.andrew.cmu.edu/",
-                         bookmark_bar_id(), f2);
-  int64 u2 = adds.AddURL("Nifty", "ftp://nifty.andrew.cmu.edu/", f1, 0);
+  int64_t f1 = adds.AddFolder("Server Folder B", bookmark_bar_id(), 0);
+  int64_t f2 = adds.AddFolder("Server Folder A", bookmark_bar_id(), f1);
+  int64_t u1 = adds.AddURL("Some old site", "ftp://nifty.andrew.cmu.edu/",
+                           bookmark_bar_id(), f2);
+  int64_t u2 = adds.AddURL("Nifty", "ftp://nifty.andrew.cmu.edu/", f1, 0);
   // u3 is a duplicate URL
-  int64 u3 = adds.AddURL("Nifty2", "ftp://nifty.andrew.cmu.edu/", f1, u2);
+  int64_t u3 = adds.AddURL("Nifty2", "ftp://nifty.andrew.cmu.edu/", f1, u2);
   // u4 is a duplicate title, different URL.
   adds.AddURL("Some old site", "http://slog.thestranger.com/",
               bookmark_bar_id(), u1);
   // u5 tests an empty-string title.
   std::string javascript_url(
       "javascript:(function(){var w=window.open(" \
       "'about:blank','gnotesWin','location=0,menubar=0," \
       "scrollbars=0,status=0,toolbar=0,width=300," \
       "height=300,resizable');});");
   adds.AddURL(std::string(), javascript_url, other_bookmarks_id(), 0);
-  int64 u6 = adds.AddURL(
-      "Sync1", "http://www.syncable.edu/", mobile_bookmarks_id(), 0);
+  int64_t u6 = adds.AddURL("Sync1", "http://www.syncable.edu/",
+                           mobile_bookmarks_id(), 0);
 
   syncer::ChangeRecordList::const_iterator it;
   // The bookmark model shouldn't yet have seen any of the nodes of |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeUnknown(it->id);
 
   adds.ApplyPendingChanges(change_processor_.get());
 
   // Make sure the bookmark model received all of the nodes in |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeMatching(&trans, it->id);
   ExpectModelMatch(&trans);
 
   // Part two: test modifications.
   FakeServerChange mods(&trans);
   // Mess with u2, and move it into empty folder f2
   // TODO(ncarter): Determine if we allow ModifyURL ops or not.
   /* std::string u2_old_url = mods.ModifyURL(u2, "http://www.google.com"); */
   std::string u2_old_title = mods.ModifyTitle(u2, "The Google");
-  int64 u2_old_parent = mods.ModifyPosition(u2, f2, 0);
+  int64_t u2_old_parent = mods.ModifyPosition(u2, f2, 0);
 
   // Now move f1 after u2.
   std::string f1_old_title = mods.ModifyTitle(f1, "Server Folder C");
-  int64 f1_old_parent = mods.ModifyPosition(f1, f2, u2);
+  int64_t f1_old_parent = mods.ModifyPosition(f1, f2, u2);
 
   // Then add u3 after f1.
-  int64 u3_old_parent = mods.ModifyPosition(u3, f2, f1);
+  int64_t u3_old_parent = mods.ModifyPosition(u3, f2, f1);
 
   std::string u6_old_title = mods.ModifyTitle(u6, "Mobile Folder A");
 
   // Test that the property changes have not yet taken effect.
   ExpectBrowserNodeTitle(u2, u2_old_title);
   /* ExpectBrowserNodeURL(u2, u2_old_url); */
   ExpectBrowserNodeParent(u2, u2_old_parent);
 
   ExpectBrowserNodeTitle(f1, f1_old_title);
   ExpectBrowserNodeParent(f1, f1_old_parent);
@@ skipping 34 matching lines @@
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeRequiringFosterParent) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
   // Stress the immediate children of other_node because that's where
   // ApplyModelChanges puts a temporary foster parent node.
   std::string url("http://dev.chromium.org/");
   FakeServerChange adds(&trans);
-  int64 f0 = other_bookmarks_id();                 // + other_node
-  int64 f1 = adds.AddFolder("f1",      f0, 0);    //   + f1
-  int64 f2 = adds.AddFolder("f2",      f1, 0);    //     + f2
-  int64 u3 = adds.AddURL(   "u3", url, f2, 0);    //       + u3    NOLINT
-  int64 u4 = adds.AddURL(   "u4", url, f2, u3);   //       + u4    NOLINT
-  int64 u5 = adds.AddURL(   "u5", url, f1, f2);   //     + u5      NOLINT
-  int64 f6 = adds.AddFolder("f6",      f1, u5);   //     + f6
-  int64 u7 = adds.AddURL(   "u7", url, f0, f1);   //   + u7        NOLINT
+  int64_t f0 = other_bookmarks_id();            // + other_node
+  int64_t f1 = adds.AddFolder("f1", f0, 0);     //   + f1
+  int64_t f2 = adds.AddFolder("f2", f1, 0);     //     + f2
+  int64_t u3 = adds.AddURL("u3", url, f2, 0);   //       + u3    NOLINT
+  int64_t u4 = adds.AddURL("u4", url, f2, u3);  //       + u4    NOLINT
+  int64_t u5 = adds.AddURL("u5", url, f1, f2);  //     + u5      NOLINT
+  int64_t f6 = adds.AddFolder("f6", f1, u5);    //     + f6
+  int64_t u7 = adds.AddURL("u7", url, f0, f1);  //   + u7        NOLINT
 
   syncer::ChangeRecordList::const_iterator it;
   // The bookmark model shouldn't yet have seen any of the nodes of |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeUnknown(it->id);
 
   adds.ApplyPendingChanges(change_processor_.get());
 
   // Make sure the bookmark model received all of the nodes in |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
@@ skipping 224 matching lines @@
 }
 
 TEST_F(ProfileSyncServiceBookmarkTest, ApplySyncDeletesFromJournal) {
   // Initialize sync model and bookmark model as:
   // URL 0
   // Folder 1
   //   |-- URL 1
   //   +-- Folder 2
   //         +-- URL 2
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
-  int64 u0 = 0;
-  int64 f1 = 0;
-  int64 u1 = 0;
-  int64 f2 = 0;
-  int64 u2 = 0;
+  int64_t u0 = 0;
+  int64_t f1 = 0;
+  int64_t u1 = 0;
+  int64_t f2 = 0;
+  int64_t u2 = 0;
   StartSync();
   int fixed_sync_bk_count = GetSyncBookmarkCount();
   {
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     FakeServerChange adds(&trans);
     u0 = adds.AddURL("URL 0", "http://plus.google.com/", bookmark_bar_id(), 0);
     f1 = adds.AddFolder("Folder 1", bookmark_bar_id(), u0);
     u1 = adds.AddURL("URL 1", "http://www.google.com/", f1, 0);
     f2 = adds.AddFolder("Folder 2", f1, u1);
     u2 = adds.AddURL("URL 2", "http://mail.google.com/", f2, 0);
@@ skipping 58 matching lines @@
   ASSERT_TRUE(test_user_share_.Reload());
   EXPECT_EQ(0u, test_user_share_.GetDeleteJournalSize());
 }
 
 struct TestData {
   const char* title;
   const char* url;
 };
 
 // Map from bookmark node ID to its version.
-typedef std::map<int64, int64> BookmarkNodeVersionMap;
+typedef std::map<int64_t, int64_t> BookmarkNodeVersionMap;
 
 // TODO(ncarter): Integrate the existing TestNode/PopulateNodeFromString code
 // in the bookmark model unittest, to make it simpler to set up test data
 // here (and reduce the amount of duplication among tests), and to reduce the
 // duplication.
 class ProfileSyncServiceBookmarkTestWithData
     : public ProfileSyncServiceBookmarkTest {
  public:
   ProfileSyncServiceBookmarkTestWithData();
 
@@ skipping 602 matching lines @@
   EXPECT_TRUE(child_node->is_url());
   model_->SetDateAdded(child_node, base::Time::FromInternalValue(10));
 
   StartSync();
   StopSync();
 
   // Verify that transaction versions are in sync between the native model
   // and Sync.
   {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    int64 sync_version = trans.GetModelVersion(syncer::BOOKMARKS);
-    int64 native_version = model_->root_node()->sync_transaction_version();
+    int64_t sync_version = trans.GetModelVersion(syncer::BOOKMARKS);
+    int64_t native_version = model_->root_node()->sync_transaction_version();
     EXPECT_EQ(native_version, sync_version);
   }
 
   // Since the version is in sync the association above should have skipped
   // updating the native node above. That is expected optimization (see
   // crbug/464907.
   EXPECT_EQ(child_node->date_added(), base::Time::FromInternalValue(10));
 
   // Reset transaction version on the native model to trigger updating data
   // for all bookmark nodes.
   model_->SetNodeSyncTransactionVersion(
       model_->root_node(), syncer::syncable::kInvalidTransactionVersion);
 
   StartSync();
 
   // Everything should be back in sync after model association.
   ExpectBookmarkModelMatchesTestData();
   ExpectModelMatch();
 
   // Now trigger a change while syncing. We add a new bookmark, sync it, then
   // updates it's creation time.
   syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   FakeServerChange adds(&trans);
   const std::string kTitle = "Some site";
   const std::string kUrl = "http://www.whatwhat.yeah/";
   const int kCreationTime = 30;
-  int64 id = adds.AddURL(kTitle, kUrl,
-                         bookmark_bar_id(), 0);
+  int64_t id = adds.AddURL(kTitle, kUrl, bookmark_bar_id(), 0);
   adds.ApplyPendingChanges(change_processor_.get());
   FakeServerChange updates(&trans);
   updates.ModifyCreationTime(id, kCreationTime);
   updates.ApplyPendingChanges(change_processor_.get());
 
   const BookmarkNode* node = model_->bookmark_bar_node()->GetChild(0);
   ASSERT_TRUE(node);
   EXPECT_TRUE(node->is_url());
   EXPECT_EQ(base::UTF8ToUTF16(kTitle), node->GetTitle());
   EXPECT_EQ(kUrl, node->url().possibly_invalid_spec());
@@ skipping 19 matching lines @@
       model_->root_node(), syncer::syncable::kInvalidTransactionVersion);
 
   // Restart sync.
   StartSync();
   StopSync();
 
   // Verify that the native transaction version has been updated and is now
   // in sync with the sync version.
   {
     syncer::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
-    int64 sync_version = trans.GetModelVersion(syncer::BOOKMARKS);
-    int64 native_version = model_->root_node()->sync_transaction_version();
+    int64_t sync_version = trans.GetModelVersion(syncer::BOOKMARKS);
+    int64_t native_version = model_->root_node()->sync_transaction_version();
     EXPECT_EQ(native_version, sync_version);
   }
 }
 
 // Tests that changes to the sync nodes meta info gets reflected in the local
 // bookmark model.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, UpdateMetaInfoFromSync) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   WriteTestDataToBookmarkModel();
   StartSync();
 
   // Create bookmark nodes containing meta info.
   syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
   FakeServerChange adds(&trans);
   BookmarkNode::MetaInfoMap folder_meta_info;
   folder_meta_info["folder"] = "foldervalue";
-  int64 folder_id = adds.AddFolderWithMetaInfo(
+  int64_t folder_id = adds.AddFolderWithMetaInfo(
       "folder title", &folder_meta_info, bookmark_bar_id(), 0);
   BookmarkNode::MetaInfoMap node_meta_info;
   node_meta_info["node"] = "nodevalue";
   node_meta_info["other"] = "othervalue";
-  int64 id = adds.AddURLWithMetaInfo("node title", "http://www.foo.com",
-                                     &node_meta_info, folder_id, 0);
+  int64_t id = adds.AddURLWithMetaInfo("node title", "http://www.foo.com",
+                                       &node_meta_info, folder_id, 0);
   adds.ApplyPendingChanges(change_processor_.get());
 
   // Verify that the nodes are created with the correct meta info.
   ASSERT_LT(0, model_->bookmark_bar_node()->child_count());
   const BookmarkNode* folder_node = model_->bookmark_bar_node()->GetChild(0);
   ASSERT_TRUE(folder_node->GetMetaInfoMap());
   EXPECT_EQ(folder_meta_info, *folder_node->GetMetaInfoMap());
   ASSERT_LT(0, folder_node->child_count());
   const BookmarkNode* node = folder_node->GetChild(0);
   ASSERT_TRUE(node->GetMetaInfoMap());
@@ skipping 47 matching lines @@
 
 // Tests that node's specifics doesn't get unnecessarily overwritten (causing
 // a subsequent commit) when BookmarkChangeProcessor handles a notification
 // (such as BookmarkMetaInfoChanged) without an actual data change.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, MetaInfoPreservedOnNonChange) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   WriteTestDataToBookmarkModel();
   StartSync();
 
   std::string orig_specifics;
-  int64 sync_id;
+  int64_t sync_id;
   const BookmarkNode* bookmark;
 
   // Create bookmark folder node containing meta info.
   {
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     FakeServerChange adds(&trans);
 
-    int64 folder_id = adds.AddFolder("folder title", bookmark_bar_id(), 0);
+    int64_t folder_id = adds.AddFolder("folder title", bookmark_bar_id(), 0);
 
     BookmarkNode::MetaInfoMap node_meta_info;
     node_meta_info["one"] = "1";
     node_meta_info["two"] = "2";
     node_meta_info["three"] = "3";
 
     sync_id = adds.AddURLWithMetaInfo("node title", "http://www.foo.com/",
                                       &node_meta_info, folder_id, 0);
 
     // Verify that the node propagates to the bookmark model
@@ skipping 24 matching lines @@
 void ProfileSyncServiceBookmarkTestWithData::GetTransactionVersions(
     const BookmarkNode* root,
     BookmarkNodeVersionMap* node_versions) {
   node_versions->clear();
   std::queue<const BookmarkNode*> nodes;
   nodes.push(root);
   while (!nodes.empty()) {
     const BookmarkNode* n = nodes.front();
     nodes.pop();
 
-    int64 version = n->sync_transaction_version();
+    int64_t version = n->sync_transaction_version();
     EXPECT_NE(BookmarkNode::kInvalidSyncTransactionVersion, version);
 
     (*node_versions)[n->id()] = version;
     for (int i = 0; i < n->child_count(); ++i) {
       if (!CanSyncNode(n->GetChild(i)))
         continue;
       nodes.push(n->GetChild(i));
     }
   }
 }
@@ skipping 97 matching lines @@
   }
   ExpectTransactionVersionMatch(model_->bookmark_bar_node(),
                                 BookmarkNodeVersionMap());
   ExpectTransactionVersionMatch(model_->other_node(),
                                 BookmarkNodeVersionMap());
   ExpectTransactionVersionMatch(model_->mobile_node(),
                                 BookmarkNodeVersionMap());
 
   // Now shut down sync and artificially increment the native model's version.
   StopSync();
-  int64 root_version = initial_versions[model_->root_node()->id()];
+  int64_t root_version = initial_versions[model_->root_node()->id()];
   model_->SetNodeSyncTransactionVersion(model_->root_node(), root_version + 1);
 
   // Upon association, bookmarks should fail to associate.
   EXPECT_FALSE(AssociateModels());
 }
 
 // It's possible for update/add calls from the bookmark model to be out of
 // order, or asynchronous. Handle that without triggering an error.
 TEST_F(ProfileSyncServiceBookmarkTest, UpdateThenAdd) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
@@ skipping 36 matching lines @@
 
   // Create a bookmark under managed_node() permanent folder.
   bookmarks::ManagedBookmarkService* managed_bookmark_service =
       ManagedBookmarkServiceFactory::GetForProfile(&profile_);
   const BookmarkNode* folder = managed_bookmark_service->managed_node();
   const BookmarkNode* node = model_->AddURL(
       folder, 0, base::ASCIIToUTF16("node"), GURL("http://www.node.com/"));
 
   // Verify that these changes are ignored by Sync.
   EXPECT_EQ(sync_bookmark_count, GetSyncBookmarkCount());
-  int64 sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
+  int64_t sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
   EXPECT_EQ(syncer::kInvalidId, sync_id);
 
   // Verify that Sync ignores deleting this node.
   model_->Remove(node);
   EXPECT_EQ(sync_bookmark_count, GetSyncBookmarkCount());
 }
 
 }  // namespace
 
 }  // namespace browser_sync