[Sync] Replacing NULL with nullptr in code and null in comments for components/sync/

components/sync/engine_impl/sync_manager_impl_unittest.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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include "components/sync/engine_impl/sync_manager_impl.h"
 
@@ skipping 418 matching lines @@
   int64_t folder_id;
   std::string test_title("test1");
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     // we'll use this spare folder later
     WriteNode folder_node(&trans);
-    EXPECT_TRUE(folder_node.InitBookmarkByCreation(root_node, NULL));
+    EXPECT_TRUE(folder_node.InitBookmarkByCreation(root_node, nullptr));
     folder_id = folder_node.GetId();
 
     WriteNode wnode(&trans);
     WriteNode::InitUniqueByCreationResult result =
         wnode.InitUniqueByCreation(BOOKMARKS, root_node, "testtag");
     EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     wnode.SetIsFolder(false);
     wnode.SetTitle(test_title);
 
     node_id = wnode.GetId();
@@ skipping 93 matching lines @@
     trans.GetCryptographer()->AddKey(params);
   }
   encryption_handler()->EnableEncryptEverything();
   int bookmark_id;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode bookmark_node(&trans);
-    ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, NULL));
+    ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, nullptr));
     bookmark_id = bookmark_node.GetId();
     bookmark_node.SetTitle("foo");
 
     WriteNode pref_node(&trans);
     WriteNode::InitUniqueByCreationResult result =
         pref_node.InitUniqueByCreation(PREFERENCES, root_node, "bar");
     ASSERT_EQ(WriteNode::INIT_SUCCESS, result);
     pref_node.SetTitle("bar");
   }
   {
@@ skipping 16 matching lines @@
 // results in single space title and non-unique name in internal representation.
 // GetTitle should still return empty string.
 TEST_F(SyncApiTest, WriteEmptyBookmarkTitle) {
   int bookmark_id;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode bookmark_node(&trans);
-    ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, NULL));
+    ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, nullptr));
     bookmark_id = bookmark_node.GetId();
     bookmark_node.SetTitle("");
   }
   {
     ReadTransaction trans(FROM_HERE, user_share());
 
     ReadNode bookmark_node(&trans);
     ASSERT_EQ(BaseNode::INIT_OK, bookmark_node.InitByIdLookup(bookmark_id));
     EXPECT_EQ("", bookmark_node.GetTitle());
     EXPECT_EQ(" ", bookmark_node.GetEntitySpecifics().bookmark().title());
@@ skipping 63 matching lines @@
 // Test counting nodes when the type's root node has no children.
 TEST_F(SyncApiTest, GetTotalNodeCountEmpty) {
   int64_t type_root = MakeTypeRoot(user_share(), BOOKMARKS);
   EXPECT_EQ(1, GetTotalNodeCount(user_share(), type_root));
 }
 
 // Test counting nodes when there is one child beneath the type's root.
 TEST_F(SyncApiTest, GetTotalNodeCountOneChild) {
   int64_t type_root = MakeTypeRoot(user_share(), BOOKMARKS);
   int64_t parent =
-      MakeFolderWithParent(user_share(), BOOKMARKS, type_root, NULL);
+      MakeFolderWithParent(user_share(), BOOKMARKS, type_root, nullptr);
   EXPECT_EQ(2, GetTotalNodeCount(user_share(), type_root));
   EXPECT_EQ(1, GetTotalNodeCount(user_share(), parent));
 }
 
 // Test counting nodes when there are multiple children beneath the type root,
 // and one of those children has children of its own.
 TEST_F(SyncApiTest, GetTotalNodeCountMultipleChildren) {
   int64_t type_root = MakeTypeRoot(user_share(), BOOKMARKS);
   int64_t parent =
-      MakeFolderWithParent(user_share(), BOOKMARKS, type_root, NULL);
-  ignore_result(MakeFolderWithParent(user_share(), BOOKMARKS, type_root, NULL));
-  int64_t child1 = MakeFolderWithParent(user_share(), BOOKMARKS, parent, NULL);
-  ignore_result(MakeBookmarkWithParent(user_share(), parent, NULL));
-  ignore_result(MakeBookmarkWithParent(user_share(), child1, NULL));
+      MakeFolderWithParent(user_share(), BOOKMARKS, type_root, nullptr);
+  ignore_result(
+      MakeFolderWithParent(user_share(), BOOKMARKS, type_root, nullptr));
+  int64_t child1 =
+      MakeFolderWithParent(user_share(), BOOKMARKS, parent, nullptr);
+  ignore_result(MakeBookmarkWithParent(user_share(), parent, nullptr));
+  ignore_result(MakeBookmarkWithParent(user_share(), child1, nullptr));
   EXPECT_EQ(6, GetTotalNodeCount(user_share(), type_root));
   EXPECT_EQ(4, GetTotalNodeCount(user_share(), parent));
 }
 
 // Verify that Directory keeps track of which attachments are referenced by
 // which entries.
 TEST_F(SyncApiTest, AttachmentLinking) {
   // Add an entry with an attachment.
   std::string tag1("some tag");
   AttachmentId attachment_id(AttachmentId::Create(0, 0));
@@ skipping 585 matching lines @@
   sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
   EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
 }
 
 TEST_F(SyncManagerTest, EncryptDataTypesWithData) {
   size_t batch_size = 5;
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
 
   // Create some unencrypted unsynced data.
   int64_t folder = MakeFolderWithParent(sync_manager_.GetUserShare(), BOOKMARKS,
-                                        GetIdForDataType(BOOKMARKS), NULL);
+                                        GetIdForDataType(BOOKMARKS), nullptr);
   // First batch_size nodes are children of folder.
   size_t i;
   for (i = 0; i < batch_size; ++i) {
-    MakeBookmarkWithParent(sync_manager_.GetUserShare(), folder, NULL);
+    MakeBookmarkWithParent(sync_manager_.GetUserShare(), folder, nullptr);
   }
   // Next batch_size nodes are a different type and on their own.
   for (; i < 2 * batch_size; ++i) {
     MakeNodeWithRoot(sync_manager_.GetUserShare(), SESSIONS,
                      base::StringPrintf("%" PRIuS "", i));
   }
   // Last batch_size nodes are a third type that will not need encryption.
   for (; i < 3 * batch_size; ++i) {
     MakeNodeWithRoot(sync_manager_.GetUserShare(), THEMES,
                      base::StringPrintf("%" PRIuS "", i));
@@ skipping 491 matching lines @@
 // set. This replicates the unique way bookmarks have of creating sync nodes.
 // See BookmarkChangeProcessor::PlaceSyncNode(..).
 TEST_F(SyncManagerTest, CreateLocalBookmark) {
   std::string title = "title";
   std::string url = "url";
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode bookmark_root(&trans);
     ASSERT_EQ(BaseNode::INIT_OK, bookmark_root.InitTypeRoot(BOOKMARKS));
     WriteNode node(&trans);
-    ASSERT_TRUE(node.InitBookmarkByCreation(bookmark_root, NULL));
+    ASSERT_TRUE(node.InitBookmarkByCreation(bookmark_root, nullptr));
     node.SetIsFolder(false);
     node.SetTitle(title);
 
     sync_pb::BookmarkSpecifics bookmark_specifics(node.GetBookmarkSpecifics());
     bookmark_specifics.set_url(url);
     node.SetBookmarkSpecifics(bookmark_specifics);
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode bookmark_root(&trans);
@@ skipping 741 matching lines @@
     return std::move(scheduler_to_use_);
   }
 
  private:
   std::unique_ptr<SyncScheduler> scheduler_to_use_;
   SyncCycleContext** cycle_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
  public:
-  SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
+  SyncManagerTestWithMockScheduler() : scheduler_(nullptr) {}
   EngineComponentsFactory* GetFactory() override {
     scheduler_ = new MockSyncScheduler();
     return new ComponentsFactory(GetSwitches(), scheduler_, &cycle_context_,
                                  &storage_used_);
   }
 
   MockSyncScheduler* scheduler() { return scheduler_; }
   SyncCycleContext* cycle_context() { return cycle_context_; }
 
  private:
@@ skipping 767 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer