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

components/sync_sessions/sessions_sync_manager.cc

 // Copyright 2014 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_sessions/sessions_sync_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 212 matching lines @@
            windows.begin();
        i != windows.end(); ++i) {
     if (option == RELOAD_TABS) {
       UMA_HISTOGRAM_COUNTS("Sync.SessionTabs", (*i)->GetTabCount());
     }
 
     // Make sure the window has tabs and a viewable window. The viewable window
     // check is necessary because, for example, when a browser is closed the
     // destructor is not necessarily run immediately. This means its possible
     // for us to get a handle to a browser that is about to be removed. If
-    // the tab count is 0 or the window is NULL, the browser is about to be
+    // the tab count is 0 or the window is null, the browser is about to be
     // deleted, so we ignore it.
     if ((*i)->ShouldSync() && (*i)->GetTabCount() && (*i)->HasWindow()) {
       sync_pb::SessionWindow window_s;
       SessionID::id_type window_id = (*i)->GetSessionId();
       DVLOG(1) << "Associating window " << window_id << " with "
                << (*i)->GetTabCount() << " tabs.";
       window_s.set_window_id(window_id);
       // Note: We don't bother to set selected tab index anymore. We still
       // consume it when receiving foreign sessions, as reading it is free, but
       // it triggers too many sync cycles with too little value to make setting
@@ skipping 32 matching lines @@
         }
 
         if (RELOAD_TABS == option)
           AssociateTab(synced_tab, change_output);
 
         // If the tab is valid, it would have been added to the tracker either
         // by the above AssociateTab call (at association time), or by the
         // change processor calling AssociateTab for all modified tabs.
         // Therefore, we can key whether this window has valid tabs based on
         // the tab's presence in the tracker.
-        const sessions::SessionTab* tab = NULL;
+        const sessions::SessionTab* tab = nullptr;
         if (session_tracker_.LookupSessionTab(local_tag, tab_id, &tab)) {
           found_tabs = true;
           window_s.add_tab(tab_id);
         }
       }
       if (found_tabs) {
         sync_pb::SessionWindow* header_window = header_s->add_window();
         *header_window = window_s;
 
         // Update this window's representation in the synced session tracker.
@@ skipping 32 matching lines @@
     }
     local_tab_pool_.FreeTabNode(tab_iter->second->tab_node_id(), change_output);
     local_tab_map_.erase(tab_iter);
     return;
   }
 
   if (!tab->ShouldSync(sessions_client_))
     return;
 
   TabLinksMap::iterator local_tab_map_iter = local_tab_map_.find(tab_id);
-  TabLink* tab_link = NULL;
+  TabLink* tab_link = nullptr;
 
   if (local_tab_map_iter == local_tab_map_.end()) {
     int tab_node_id = tab->GetSyncId();
     // If there is an old sync node for the tab, reuse it.  If this is a new
     // tab, get a sync node for it.
     if (!local_tab_pool_.IsUnassociatedTabNode(tab_node_id)) {
       tab_node_id = local_tab_pool_.GetFreeTabNode(change_output);
       tab->SetSyncId(tab_node_id);
     }
     local_tab_pool_.AssociateTabNode(tab_node_id, tab_id);
@@ skipping 107 matching lines @@
   }
 }
 
 void SessionsSyncManager::StopSyncing(syncer::ModelType type) {
   local_event_router_->Stop();
   if (sync_processor_.get() && lost_navigations_recorder_.get()) {
     sync_processor_->RemoveLocalChangeObserver(
         lost_navigations_recorder_.get());
     lost_navigations_recorder_.reset();
   }
-  sync_processor_.reset(NULL);
+  sync_processor_.reset(nullptr);
   error_handler_.reset();
   session_tracker_.Clear();
   local_tab_map_.clear();
   local_tab_pool_.Clear();
   current_machine_tag_.clear();
   current_session_name_.clear();
   local_session_header_node_id_ = TabNodePool::kInvalidTabNodeID;
 }
 
 syncer::SyncDataList SessionsSyncManager::GetAllSyncData(
     syncer::ModelType type) const {
   syncer::SyncDataList list;
-  const SyncedSession* session = NULL;
+  const SyncedSession* session = nullptr;
   if (!session_tracker_.LookupLocalSession(&session))
     return syncer::SyncDataList();
 
   // First construct the header node.
   sync_pb::EntitySpecifics header_entity;
   header_entity.mutable_session()->set_session_tag(current_machine_tag());
   sync_pb::SessionHeader* header_specifics =
       header_entity.mutable_session()->mutable_header();
   header_specifics->MergeFrom(session->ToSessionHeader());
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
@@ skipping 449 matching lines @@
       tabs->push_back(tab);
     }
   }
   std::sort(tabs->begin(), tabs->end(), TabsRecencyComparator);
   return true;
 }
 
 bool SessionsSyncManager::GetForeignTab(const std::string& tag,
                                         const SessionID::id_type tab_id,
                                         const sessions::SessionTab** tab) {
-  const sessions::SessionTab* synced_tab = NULL;
+  const sessions::SessionTab* synced_tab = nullptr;
   bool success = session_tracker_.LookupSessionTab(tag, tab_id, &synced_tab);
   if (success)
     *tab = synced_tab;
   return success;
 }
 
 void SessionsSyncManager::LocalTabDelegateToSpecifics(
     const SyncedTabDelegate& tab_delegate,
     sync_pb::SessionSpecifics* specifics) {
-  sessions::SessionTab* session_tab = NULL;
+  sessions::SessionTab* session_tab = nullptr;
   session_tab = session_tracker_.GetTab(current_machine_tag(),
                                         tab_delegate.GetSessionId(),
                                         tab_delegate.GetSyncId());
   SetSessionTabFromDelegate(tab_delegate, base::Time::Now(), session_tab);
   SetVariationIds(session_tab);
   sync_pb::SessionTab tab_s = session_tab->ToSyncData();
   specifics->set_session_tag(current_machine_tag_);
   specifics->set_tab_node_id(tab_delegate.GetSyncId());
   specifics->mutable_tab()->CopyFrom(tab_s);
 }
@@ skipping 154 matching lines @@
 }
 
 // static
 std::string SessionsSyncManager::TagHashFromSpecifics(
     const sync_pb::SessionSpecifics& specifics) {
   return syncer::syncable::GenerateSyncableHash(syncer::SESSIONS,
                                                 TagFromSpecifics(specifics));
 }
 
 };  // namespace sync_sessions