[Sync] Replacing NULL with nullptr/null throughout sync code.

components/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>
@@ skipping 100 matching lines @@
   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));
+      EXPECT_TRUE(node.InitBookmarkByCreation(parent, nullptr));
     } 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));
     }
     EXPECT_EQ(node.GetPredecessorId(), predecessor_id);
     EXPECT_EQ(node.GetParentId(), parent_id);
     node.SetIsFolder(is_folder);
     node.SetTitle(title);
@@ skipping 12 matching lines @@
     record.id = node.GetId();
     changes_.push_back(record);
     return node.GetId();
   }
 
   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,
+    return AddWithMetaInfo(title, url, nullptr, is_folder, parent_id,
                            predecessor_id);
   }
 
   // Add a bookmark folder.
   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_t AddFolderWithMetaInfo(const std::string& title,
@@ skipping 63 matching lines @@
   // very useful for assertions.
   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_t old_parent_id = node.GetParentId();
     if (predecessor_id == 0) {
-      EXPECT_TRUE(node.SetPosition(parent, NULL));
+      EXPECT_TRUE(node.SetPosition(parent, nullptr));
     } 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;
   }
 
@@ skipping 143 matching lines @@
   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));
+    EXPECT_TRUE(node.InitBookmarkByCreation(bookmark_bar, nullptr));
     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_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);
-    EXPECT_TRUE(node.InitBookmarkByCreation(parent, NULL));
+    EXPECT_TRUE(node.InitBookmarkByCreation(parent, nullptr));
     node.SetIsFolder(false);
     node.SetTitle(title);
     node.SetBookmarkSpecifics(specifics);
 
     return node.GetId();
   }
 
   // Create a BookmarkModel. If |delete_bookmarks| is true, the bookmarks file
   // will be deleted before starting up the BookmarkModel.
   std::unique_ptr<BookmarkModel> CreateBookmarkModel(bool delete_bookmarks) {
@@ skipping 75 matching lines @@
       syncer::ReadNode lookup(&trans);
       if (lookup.InitByTagLookupForBookmarks(permanent_tags[i]) ==
           syncer::ReadNode::INIT_OK) {
         last_child_id = lookup.GetId();
         continue;
       }
 
       // If it doesn't exist, create the permanent node at the end of the
       // ordering.
       syncer::ReadNode predecessor_node(&trans);
-      syncer::ReadNode* predecessor = NULL;
+      syncer::ReadNode* predecessor = nullptr;
       if (last_child_id != syncer::kInvalidId) {
         EXPECT_EQ(BaseNode::INIT_OK,
                   predecessor_node.InitByIdLookup(last_child_id));
         predecessor = &predecessor_node;
       }
       syncer::WriteNode node(&trans);
       if (!node.InitBookmarkByCreation(root, predecessor))
         return false;
       node.SetIsFolder(true);
       node.GetMutableEntryForTest()->PutUniqueServerTag(permanent_tags[i]);
@@ skipping 117 matching lines @@
       EXPECT_EQ(gnode.GetPredecessorId(), 0);
     } else {
       const BookmarkNode* bprev = bnode->parent()->GetChild(browser_index - 1);
       syncer::ReadNode gprev(trans);
       ASSERT_TRUE(InitSyncNodeFromChromeNode(bprev, &gprev));
       EXPECT_EQ(gnode.GetPredecessorId(), gprev.GetId());
       EXPECT_EQ(gnode.GetParentId(), gprev.GetParentId());
     }
     // Note: the managed node is the last child of the root_node but isn't
     // synced; if CanSyncNode() is false then there is no next node to sync.
-    const BookmarkNode* bnext = NULL;
+    const BookmarkNode* bnext = nullptr;
     if (browser_index + 1 < bnode->parent()->child_count())
       bnext = bnode->parent()->GetChild(browser_index + 1);
     if (!bnext || !CanSyncNode(bnext)) {
       EXPECT_EQ(gnode.GetSuccessorId(), 0);
     } else {
       syncer::ReadNode gnext(trans);
       ASSERT_TRUE(InitSyncNodeFromChromeNode(bnext, &gnext));
       EXPECT_EQ(gnode.GetSuccessorId(), gnext.GetId());
       EXPECT_EQ(gnode.GetParentId(), gnext.GetParentId());
     }
@@ skipping 311 matching lines @@
   // Number of nodes in bookmark bar before association.
   int total_node_count = model()->bookmark_bar_node()->GetTotalNodeCount();
 
   CreatePermanentBookmarkNodes();
 
   int64_t sync_bookmark_id_to_delete = 0;
   {
     // Create sync folders matching native folders above.
     int64_t parent_id = 0;
     syncer::WriteTransaction trans(FROM_HERE, test_user_share()->user_share());
-    // Create in reverse order because AddFolderToShare passes NULL for
+    // Create in reverse order because AddFolderToShare passes null for
     // |predecessor| argument.
     for (int i = kNumFolders - 1; i >= 0; i--) {
       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]);
 
       if (i == kFolderToIncludeBookmarks) {
         parent_id = id;
       }
     }
 
     // Create sync bookmark matching native bookmarks above in reverse order
-    // because AddBookmarkToShare passes NULL for |predecessor| argument.
+    // because AddBookmarkToShare passes null for |predecessor| argument.
     for (int i = kNumBookmarks - 1; i >= 0; i--) {
       int id = AddBookmarkToShare(&trans, parent_id, "bookmark",
                                   "http://www.google.com/");
 
       // Pre-map sync bookmarks to native bookmarks by setting
       // external ID. This will verify that the association algorithm picks
       // the right ones despite all of them having identical names and URLs.
       syncer::WriteNode node(&trans);
       EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
       node.GetMutableEntryForTest()->PutLocalExternalId(bookmark_ids[i]);
@@ skipping 659 matching lines @@
 // +-- Mobile bookmarks
 //     |-- f5
 //     |   |-- f5u1, http://www.f5u1.com/
 //     |-- f6
 //     |   |-- f6u1, http://www.f6u1.com/
 //     |   |-- f6u2, http://www.f6u2.com/
 //     +-- u5, http://www.u5.com/
 
 static TestData kBookmarkBarChildren[] = {
     {"u2", "http://www.u2.com/"},
-    {"f1", NULL},
+    {"f1", nullptr},
     {"u1", "http://www.u1.com/"},
-    {"f2", NULL},
+    {"f2", nullptr},
 };
 static TestData kF1Children[] = {
     {"f1u4", "http://www.f1u4.com/"},
     {"f1u2", "http://www.f1u2.com/"},
     {"f1u3", "http://www.f1u3.com/"},
     {"f1u1", "http://www.f1u1.com/"},
 };
 static TestData kF2Children[] = {
     {"f2u2", "http://www.f2u2.com/"},
     {"f2u4", "http://www.f2u4.com/"},
     {"f2u3", "http://www.f2u3.com/"},
     {"f2u1", "http://www.f2u1.com/"},
 };
 
-static TestData kOtherBookmarkChildren[] = {{"f3", NULL},
+static TestData kOtherBookmarkChildren[] = {{"f3", nullptr},
                                             {"u4", "http://www.u4.com/"},
                                             {"u3", "http://www.u3.com/"},
-                                            {"f4", NULL},
-                                            {"dup", NULL},
-                                            {"dup", NULL},
+                                            {"f4", nullptr},
+                                            {"dup", nullptr},
+                                            {"dup", nullptr},
                                             {"  ls  ", "http://www.ls.com/"}};
 static TestData kF3Children[] = {
     {"f3u4", "http://www.f3u4.com/"},
     {"f3u2", "http://www.f3u2.com/"},
     {"f3u3", "http://www.f3u3.com/"},
     {"f3u1", "http://www.f3u1.com/"},
 };
 static TestData kF4Children[] = {
     {"f4u1", "http://www.f4u1.com/"},
     {"f4u2", "http://www.f4u2.com/"},
     {"f4u3", "http://www.f4u3.com/"},
     {"f4u4", "http://www.f4u4.com/"},
 };
 static TestData kDup1Children[] = {
     {"dupu1", "http://www.dupu1.com/"},
 };
 static TestData kDup2Children[] = {
     {"dupu2", "http://www.dupu2.com/"},
 };
 
 static TestData kMobileBookmarkChildren[] = {
-    {"f5", NULL},
-    {"f6", NULL},
+    {"f5", nullptr},
+    {"f6", nullptr},
     {"u5", "http://www.u5.com/"},
 };
 static TestData kF5Children[] = {
     {"f5u1", "http://www.f5u1.com/"},
     {"f5u2", "http://www.f5u2.com/"},
 };
 static TestData kF6Children[] = {
     {"f6u1", "http://www.f6u1.com/"},
     {"f6u2", "http://www.f6u2.com/"},
 };
@@ skipping 11 matching lines @@
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   for (int i = 0; i < size; ++i) {
     const TestData& item = data[i];
     if (item.url) {
       const base::Time add_time =
           start_time_ + base::TimeDelta::FromMinutes(*running_count);
       model()->AddURLWithCreationTimeAndMetaInfo(
           node, i, base::UTF8ToUTF16(item.title), GURL(item.url), add_time,
-          NULL);
+          nullptr);
     } else {
       model()->AddFolder(node, i, base::UTF8ToUTF16(item.title));
     }
     (*running_count)++;
   }
 }
 
 void ProfileSyncServiceBookmarkTestWithData::CompareWithTestData(
     const BookmarkNode* node,
     const TestData* data,
     int size,
     int* running_count) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   ASSERT_EQ(size, node->child_count());
   for (int i = 0; i < size; ++i) {
     const BookmarkNode* child_node = node->GetChild(i);
     const TestData& item = data[i];
-    GURL url = GURL(item.url == NULL ? "" : item.url);
+    GURL url = GURL(item.url == nullptr ? "" : item.url);
     BookmarkNode test_node(url);
     test_node.SetTitle(base::UTF8ToUTF16(item.title));
     EXPECT_EQ(child_node->GetTitle(), test_node.GetTitle());
     if (item.url) {
       EXPECT_FALSE(child_node->is_folder());
       EXPECT_TRUE(child_node->is_url());
       EXPECT_EQ(child_node->url(), test_node.url());
       const base::Time expected_time =
           start_time_ + base::TimeDelta::FromMinutes(*running_count);
       EXPECT_EQ(expected_time.ToInternalValue(),
@@ skipping 787 matching lines @@
   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