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

chrome/browser/sync/test/integration/bookmarks_helper.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.
 
 #include "chrome/browser/sync/test/integration/bookmarks_helper.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 124 matching lines @@
   BookmarkModel* model_;
   const BookmarkNode* node_;
   bool wait_for_load_;
   DISALLOW_COPY_AND_ASSIGN(FaviconChangeObserver);
 };
 
 // A collection of URLs for which we have added favicons. Since loading a
 // favicon is an asynchronous operation and doesn't necessarily invoke a
 // callback, this collection is used to determine if we must wait for a URL's
 // favicon to load or not.
-std::set<GURL>* urls_with_favicons_ = NULL;
+std::set<GURL>* urls_with_favicons_ = nullptr;
 
 // Returns the number of nodes of node type |node_type| in |model| whose
 // titles match the string |title|.
 int CountNodesWithTitlesMatching(BookmarkModel* model,
                                  BookmarkNode::Type node_type,
                                  const base::string16& title) {
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   // Walk through the model tree looking for bookmark nodes of node type
   // |node_type| whose titles match |title|.
   int count = 0;
@@ skipping 192 matching lines @@
   SkBitmap bitmap_a = image_a.AsImageSkia().GetRepresentation(
       1.0f).sk_bitmap();
   SkBitmap bitmap_b = image_b.AsImageSkia().GetRepresentation(
       1.0f).sk_bitmap();
   return FaviconRawBitmapsMatch(bitmap_a, bitmap_b);
 }
 
 // Does a deep comparison of BookmarkNode fields in |model_a| and |model_b|.
 // Returns true if they are all equal.
 bool NodesMatch(const BookmarkNode* node_a, const BookmarkNode* node_b) {
-  if (node_a == NULL || node_b == NULL)
+  if (node_a == nullptr || node_b == nullptr)
     return node_a == node_b;
   if (node_a->is_folder() != node_b->is_folder()) {
     LOG(ERROR) << "Cannot compare folder with bookmark";
     return false;
   }
   if (node_a->GetTitle() != node_b->GetTitle()) {
     LOG(ERROR) << "Title mismatch: " << node_a->GetTitle() << " vs. "
                << node_b->GetTitle();
     return false;
   }
@@ skipping 120 matching lines @@
 
 const BookmarkNode* AddURL(int profile,
                            const BookmarkNode* parent,
                            int index,
                            const std::string& title,
                            const GURL& url) {
   BookmarkModel* model = GetBookmarkModel(profile);
   if (bookmarks::GetBookmarkNodeByID(model, parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
-    return NULL;
+    return nullptr;
   }
   const BookmarkNode* result =
       model->AddURL(parent, index, base::UTF8ToUTF16(title), url);
   if (!result) {
     LOG(ERROR) << "Could not add bookmark " << title << " to Profile "
                << profile;
-    return NULL;
+    return nullptr;
   }
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_parent = NULL;
+    const BookmarkNode* v_parent = nullptr;
     FindNodeInVerifier(model, parent, &v_parent);
     const BookmarkNode* v_node = GetVerifierBookmarkModel()->AddURL(
         v_parent, index, base::UTF8ToUTF16(title), url);
     if (!v_node) {
       LOG(ERROR) << "Could not add bookmark " << title << " to the verifier";
-      return NULL;
+      return nullptr;
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
 const BookmarkNode* AddFolder(int profile,
                               const std::string& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), 0, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               int index,
                               const std::string& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), index, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               const BookmarkNode* parent,
                               int index,
                               const std::string& title) {
   BookmarkModel* model = GetBookmarkModel(profile);
   if (bookmarks::GetBookmarkNodeByID(model, parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
-    return NULL;
+    return nullptr;
   }
   const BookmarkNode* result =
       model->AddFolder(parent, index, base::UTF8ToUTF16(title));
   EXPECT_TRUE(result);
   if (!result) {
     LOG(ERROR) << "Could not add folder " << title << " to Profile "
                << profile;
-    return NULL;
+    return nullptr;
   }
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_parent = NULL;
+    const BookmarkNode* v_parent = nullptr;
     FindNodeInVerifier(model, parent, &v_parent);
     const BookmarkNode* v_node = GetVerifierBookmarkModel()->AddFolder(
         v_parent, index, base::UTF8ToUTF16(title));
     if (!v_node) {
       LOG(ERROR) << "Could not add folder " << title << " to the verifier";
-      return NULL;
+      return nullptr;
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
 void SetTitle(int profile,
               const BookmarkNode* node,
               const std::string& new_title) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_node = NULL;
+    const BookmarkNode* v_node = nullptr;
     FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->SetTitle(v_node, base::UTF8ToUTF16(new_title));
   }
   model->SetTitle(node, base::UTF8ToUTF16(new_title));
 }
 
 void SetFavicon(int profile,
                 const BookmarkNode* node,
                 const GURL& icon_url,
                 const gfx::Image& image,
                 FaviconSource favicon_source) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   ASSERT_EQ(BookmarkNode::URL, node->type()) << "Node " << node->GetTitle()
                                              << " must be a url.";
-  if (urls_with_favicons_ == NULL)
+  if (urls_with_favicons_ == nullptr)
     urls_with_favicons_ = new std::set<GURL>();
   urls_with_favicons_->insert(node->url());
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_node = NULL;
+    const BookmarkNode* v_node = nullptr;
     FindNodeInVerifier(model, node, &v_node);
     SetFaviconImpl(sync_datatype_helper::test()->verifier(),
                    v_node,
                    icon_url,
                    image,
                    favicon_source);
   }
   SetFaviconImpl(sync_datatype_helper::test()->GetProfile(profile),
                  node,
                  icon_url,
@@ skipping 36 matching lines @@
   run_loop.Run();
 }
 
 const BookmarkNode* SetURL(int profile,
                            const BookmarkNode* node,
                            const GURL& new_url) {
   BookmarkModel* model = GetBookmarkModel(profile);
   if (bookmarks::GetBookmarkNodeByID(model, node->id()) != node) {
     LOG(ERROR) << "Node " << node->GetTitle() << " does not belong to "
                << "Profile " << profile;
-    return NULL;
+    return nullptr;
   }
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_node = NULL;
+    const BookmarkNode* v_node = nullptr;
     FindNodeInVerifier(model, node, &v_node);
     if (v_node->is_url())
       GetVerifierBookmarkModel()->SetURL(v_node, new_url);
   }
   if (node->is_url())
     model->SetURL(node, new_url);
   return node;
 }
 
 void Move(int profile,
           const BookmarkNode* node,
           const BookmarkNode* new_parent,
           int index) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_new_parent = NULL;
-    const BookmarkNode* v_node = NULL;
+    const BookmarkNode* v_new_parent = nullptr;
+    const BookmarkNode* v_node = nullptr;
     FindNodeInVerifier(model, new_parent, &v_new_parent);
     FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->Move(v_node, v_new_parent, index);
   }
   model->Move(node, new_parent, index);
 }
 
 void Remove(int profile, const BookmarkNode* parent, int index) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_parent = NULL;
+    const BookmarkNode* v_parent = nullptr;
     FindNodeInVerifier(model, parent, &v_parent);
     ASSERT_TRUE(NodesMatch(parent->GetChild(index), v_parent->GetChild(index)));
     GetVerifierBookmarkModel()->Remove(v_parent->GetChild(index));
   }
   model->Remove(parent->GetChild(index));
 }
 
 void RemoveAll(int profile) {
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* root_node = GetVerifierBookmarkModel()->root_node();
     for (int i = 0; i < root_node->child_count(); ++i) {
       const BookmarkNode* permanent_node = root_node->GetChild(i);
       for (int j = permanent_node->child_count() - 1; j >= 0; --j) {
         GetVerifierBookmarkModel()->Remove(permanent_node->GetChild(j));
       }
     }
   }
   GetBookmarkModel(profile)->RemoveAllUserBookmarks();
 }
 
 void SortChildren(int profile, const BookmarkNode* parent) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
-    const BookmarkNode* v_parent = NULL;
+    const BookmarkNode* v_parent = nullptr;
     FindNodeInVerifier(model, parent, &v_parent);
     GetVerifierBookmarkModel()->SortChildren(v_parent);
   }
   model->SortChildren(parent);
 }
 
 void ReverseChildOrder(int profile, const BookmarkNode* parent) {
   ASSERT_EQ(
       bookmarks::GetBookmarkNodeByID(GetBookmarkModel(profile), parent->id()),
       parent)
@@ skipping 78 matching lines @@
   std::vector<const BookmarkNode*> nodes;
   GetBookmarkModel(profile)->GetNodesByURL(url, &nodes);
   return !nodes.empty();
 }
 
 const BookmarkNode* GetUniqueNodeByURL(int profile, const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   GetBookmarkModel(profile)->GetNodesByURL(url, &nodes);
   EXPECT_EQ(1U, nodes.size());
   if (nodes.empty())
-    return NULL;
+    return nullptr;
   return nodes[0];
 }
 
 int CountAllBookmarks(int profile) {
   return CountNodes(GetBookmarkModel(profile), BookmarkNode::URL);
 }
 
 int CountBookmarksWithTitlesMatching(int profile, const std::string& title) {
   return CountNodesWithTitlesMatching(GetBookmarkModel(profile),
                                       BookmarkNode::URL,
@@ skipping 119 matching lines @@
 }  // namespace
 
 BookmarksUrlChecker::BookmarksUrlChecker(int profile,
                                          const GURL& url,
                                          int expected_count)
     : AwaitMatchStatusChangeChecker(base::Bind(BookmarkCountsByUrlMatch,
                                                profile,
                                                base::ConstRef(url),
                                                expected_count),
                                     "Bookmark URL counts match.") {}