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

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>
@@ skipping 29 matching lines @@
 
 namespace sync_bookmarks {
 
 static const char kMobileBookmarksTag[] = "synced_bookmarks";
 
 BookmarkChangeProcessor::BookmarkChangeProcessor(
     syncer::SyncClient* sync_client,
     BookmarkModelAssociator* model_associator,
     std::unique_ptr<syncer::DataTypeErrorHandler> err_handler)
     : syncer::ChangeProcessor(std::move(err_handler)),
-      bookmark_model_(NULL),
+      bookmark_model_(nullptr),
       sync_client_(sync_client),
       model_associator_(model_associator) {
   DCHECK(model_associator);
   DCHECK(sync_client);
   DCHECK(error_handler());
 }
 
 BookmarkChangeProcessor::~BookmarkChangeProcessor() {
   if (bookmark_model_)
     bookmark_model_->RemoveObserver(this);
@@ skipping 212 matching lines @@
   }
 }
 
 void BookmarkChangeProcessor::BookmarkModelLoaded(BookmarkModel* model,
                                                   bool ids_reassigned) {
   NOTREACHED();
 }
 
 void BookmarkChangeProcessor::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
-  bookmark_model_ = NULL;
+  bookmark_model_ = nullptr;
 }
 
 void BookmarkChangeProcessor::BookmarkNodeAdded(BookmarkModel* model,
                                                 const BookmarkNode* parent,
                                                 int index) {
   DCHECK(share_handle());
   const BookmarkNode* node = parent->GetChild(index);
   if (CanSyncNode(node))
     CreateOrUpdateSyncNode(node);
 }
@@ skipping 222 matching lines @@
       syncer::WriteNode* dst, BookmarkModelAssociator* associator) {
   syncer::ReadNode sync_parent(trans);
   if (!associator->InitSyncNodeFromChromeId(parent->id(), &sync_parent)) {
     LOG(WARNING) << "Parent lookup failed";
     return false;
   }
 
   bool success = false;
   if (index == 0) {
     // Insert into first position.
-    success = (operation == CREATE) ?
-        dst->InitBookmarkByCreation(sync_parent, NULL) :
-        dst->SetPosition(sync_parent, NULL);
+    success = (operation == CREATE)
+                  ? dst->InitBookmarkByCreation(sync_parent, nullptr)
+                  : dst->SetPosition(sync_parent, nullptr);
     if (success) {
       DCHECK_EQ(dst->GetParentId(), sync_parent.GetId());
       DCHECK_EQ(dst->GetId(), sync_parent.GetFirstChildId());
       DCHECK_EQ(dst->GetPredecessorId(), syncer::kInvalidId);
     }
   } else {
     // Find the bookmark model predecessor, and insert after it.
     const BookmarkNode* prev = parent->GetChild(index - 1);
     syncer::ReadNode sync_prev(trans);
     if (!associator->InitSyncNodeFromChromeId(prev->id(), &sync_prev)) {
@@ skipping 48 matching lines @@
       sync_client_->GetBookmarkUndoServiceIfExists());
 
   // Notify UI intensive observers of BookmarkModel that we are about to make
   // potentially significant changes to it, so the updates may be batched. For
   // example, on Mac, the bookmarks bar displays animations when bookmark items
   // are added or deleted.
   model->BeginExtensiveChanges();
 
   // A parent to hold nodes temporarily orphaned by parent deletion.  It is
   // created only if it is needed.
-  const BookmarkNode* foster_parent = NULL;
+  const BookmarkNode* foster_parent = nullptr;
 
   // Iterate over the deletions, which are always at the front of the list.
   ChangeRecordList::const_iterator it;
   for (it = changes.Get().begin();
        it != changes.Get().end() && it->action == ChangeRecord::ACTION_DELETE;
        ++it) {
     const BookmarkNode* dst =
         model_associator_->GetChromeNodeFromSyncId(it->id);
 
     // Ignore changes to the permanent top-level nodes.  We only care about
@@ skipping 52 matching lines @@
         model_associator_->GetChromeNodeFromSyncId(it->id);
 
     // Ignore changes to the permanent top-level nodes.  We only care about
     // their children.
     if (model->is_permanent_node(dst))
       continue;
 
     // Because the Synced Bookmarks node can be created server side, it's
     // possible it'll arrive at the client as an update. In that case it won't
     // have been associated at startup, the GetChromeNodeFromSyncId call above
-    // will return NULL, and we won't detect it as a permanent node, resulting
+    // will return null, and we won't detect it as a permanent node, resulting
     // in us trying to create it here (which will fail). Therefore, we add
     // special logic here just to detect the Synced Bookmarks folder.
     if (synced_bookmarks_id != syncer::kInvalidId &&
         it->id == synced_bookmarks_id) {
       // This is a newly created Synced Bookmarks node. Associate it.
       model_associator_->Associate(model->mobile_node(), synced_bookmarks);
       continue;
     }
 
     DCHECK_NE(it->action, ChangeRecord::ACTION_DELETE)
@@ skipping 53 matching lines @@
        to_reposition.begin(); it != to_reposition.end(); ++it) {
     const BookmarkNode* parent = it->second->parent();
     model->Move(it->second, parent, it->first);
   }
 
   // Clean up the temporary node.
   if (foster_parent) {
     // There should be no nodes left under the foster parent.
     DCHECK_EQ(foster_parent->child_count(), 0);
     model->Remove(foster_parent);
-    foster_parent = NULL;
+    foster_parent = nullptr;
   }
 
   // Notify UI intensive observers of BookmarkModel that all updates have been
   // applied, and that they may now be consumed. This prevents issues like the
   // one described in crbug.com/281562, where old and new items on the bookmarks
   // bar would overlap.
   model->EndExtensiveChanges();
 
   // We are now ready to hear about bookmarks changes again.
   model->AddObserver(this);
@@ skipping 199 matching lines @@
                                 favicon_base::FAVICON,
                                 bitmap_data,
                                 pixel_size);
 }
 
 // static
 void BookmarkChangeProcessor::SetSyncNodeFavicon(
     const BookmarkNode* bookmark_node,
     BookmarkModel* model,
     syncer::WriteNode* sync_node) {
-  scoped_refptr<base::RefCountedMemory> favicon_bytes(NULL);
+  scoped_refptr<base::RefCountedMemory> favicon_bytes(nullptr);
   EncodeFavicon(bookmark_node, model, &favicon_bytes);
   if (favicon_bytes.get() && favicon_bytes->size()) {
     sync_pb::BookmarkSpecifics updated_specifics(
         sync_node->GetBookmarkSpecifics());
     updated_specifics.set_favicon(favicon_bytes->front(),
                                   favicon_bytes->size());
     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 sync_bookmarks