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

chrome/browser/sync/sessions/sessions_sync_manager_unittest.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 <stdint.h>
 
 #include <utility>
 
@@ skipping 170 matching lines @@
     local_change_observers_.AddObserver(observer);
   }
   void RemoveLocalChangeObserver(
       syncer::LocalChangeObserver* observer) override {
     local_change_observers_.RemoveObserver(observer);
   }
 
   void NotifyLocalChangeObservers() {
     const syncer::SyncChange empty_change;
     for (syncer::LocalChangeObserver& observer : local_change_observers_)
-      observer.OnLocalChange(NULL, empty_change);
+      observer.OnLocalChange(nullptr, empty_change);
   }
 
   void FailProcessSyncChangesWith(const syncer::SyncError& error) {
     error_ = error;
   }
 
   void SetSyncDataToReturn(const syncer::SyncDataList& data) {
     sync_data_to_return_ = data;
   }
 
@@ skipping 99 matching lines @@
  private:
   SyncSessionsClient* const sync_sessions_client_;
   SyncedWindowDelegatesGetter* synced_window_getter_;
 };
 
 }  // namespace
 
 class SessionsSyncManagerTest
     : public BrowserWithTestWindowTest {
  protected:
-  SessionsSyncManagerTest()
-      : test_processor_(NULL) {
+  SessionsSyncManagerTest() : test_processor_(nullptr) {
     local_device_ = base::MakeUnique<LocalDeviceInfoProviderMock>(
         "cache_guid", "Wayne Gretzky's Hacking Box", "Chromium 10k",
         "Chrome 10k", sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id");
   }
 
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
     sync_client_ = base::MakeUnique<browser_sync::ChromeSyncClient>(profile());
     sessions_client_shim_ = base::MakeUnique<SyncSessionsClientShim>(
         sync_client_->GetSyncSessionsClient());
     NotificationServiceSessionsRouter* router(
         new NotificationServiceSessionsRouter(
             profile(), GetSyncSessionsClient(),
             syncer::SyncableService::StartSyncFlare()));
     sync_prefs_ = base::MakeUnique<syncer::SyncPrefs>(profile()->GetPrefs());
     manager_ = base::MakeUnique<SessionsSyncManager>(
         GetSyncSessionsClient(), sync_prefs_.get(), local_device_.get(),
         std::unique_ptr<LocalSessionEventRouter>(router),
         base::Bind(&SessionNotificationObserver::NotifyOfUpdate,
                    base::Unretained(&observer_)),
         base::Bind(&SessionNotificationObserver::NotifyOfRefresh,
                    base::Unretained(&observer_)));
   }
 
   void TearDown() override {
-    test_processor_ = NULL;
+    test_processor_ = nullptr;
     helper()->Reset();
     sync_prefs_.reset();
     manager_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
   const DeviceInfo* GetLocalDeviceInfo() {
     return local_device_->GetLocalDeviceInfo();
   }
 
   SessionsSyncManager* manager() { return manager_.get(); }
   SessionSyncTestHelper* helper() { return &helper_; }
   LocalDeviceInfoProvider* local_device() { return local_device_.get(); }
   SessionNotificationObserver* observer() { return &observer_; }
 
   void InitWithSyncDataTakeOutput(const syncer::SyncDataList& initial_data,
                                   syncer::SyncChangeList* output) {
     test_processor_ = new TestSyncProcessorStub(output);
     syncer::SyncMergeResult result = manager_->MergeDataAndStartSyncing(
         syncer::SESSIONS, initial_data,
         std::unique_ptr<syncer::SyncChangeProcessor>(test_processor_),
         std::unique_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock()));
     EXPECT_FALSE(result.error().IsSet());
   }
 
   void InitWithNoSyncData() {
-    InitWithSyncDataTakeOutput(syncer::SyncDataList(), NULL);
+    InitWithSyncDataTakeOutput(syncer::SyncDataList(), nullptr);
   }
 
   void TriggerProcessSyncChangesError() {
     test_processor_->FailProcessSyncChangesWith(syncer::SyncError(
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR, "Error",
         syncer::SESSIONS));
   }
 
   void SetSyncData(const syncer::SyncDataList& data) {
      test_processor_->SetSyncDataToReturn(data);
@@ skipping 434 matching lines @@
 }
 
 // Tests that variation ids are set correctly.
 TEST_F(SessionsSyncManagerTest, SetVariationIds) {
   // Create two trials with a group which has a variation id for Chrome Sync
   // and one with a variation id for another service.
   const variations::VariationID kVariationId1 = 3300200;
   const variations::VariationID kVariationId2 = 3300300;
   const variations::VariationID kVariationId3 = 3300400;
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
   CreateAndActivateFieldTrial("trial name 1", "group name", kVariationId1,
                               variations::CHROME_SYNC_SERVICE);
   CreateAndActivateFieldTrial("trial name 2", "group name", kVariationId2,
                               variations::CHROME_SYNC_SERVICE);
   CreateAndActivateFieldTrial("trial name 3", "group name", kVariationId3,
                               variations::GOOGLE_UPDATE_SERVICE);
 
   sessions::SessionTab session_tab;
   manager()->SetVariationIds(&session_tab);
 
@@ skipping 1772 matching lines @@
   base::Time last_time;
   for (size_t i = 0; i < tabs.size(); ++i) {
     base::Time this_time = tabs[i]->timestamp;
     if (i > 0)
       ASSERT_GE(last_time, this_time);
     last_time = tabs[i]->timestamp;
   }
 }
 
 }  // namespace sync_sessions