Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/aec/aec_core.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 183 matching lines @@
 
 void BlockBuffer::ReInit() {
   WebRtc_InitBuffer(buffer_);
 }
 
 void BlockBuffer::Insert(const float block[PART_LEN]) {
   WebRtc_WriteBuffer(buffer_, block, 1);
 }
 
 void BlockBuffer::ExtractExtendedBlock(float extended_block[PART_LEN2]) {
-  float* block_ptr = NULL;
+  float* block_ptr = nullptr;
   RTC_DCHECK_LT(0, AvaliableSpace());
 
   // Extract the previous block.
   WebRtc_MoveReadPtr(buffer_, -1);
   WebRtc_ReadBuffer(buffer_, reinterpret_cast<void**>(&block_ptr),
                     &extended_block[0], 1);
   if (block_ptr != &extended_block[0]) {
     memcpy(&extended_block[0], block_ptr, PART_LEN * sizeof(float));
   }
 
@@ skipping 956 matching lines @@
   int i;
   size_t j;
 
   // Coherence and non-linear filter
   float cohde[PART_LEN1], cohxd[PART_LEN1];
   float hNl[PART_LEN1];
 
   // Filter energy
   const int delayEstInterval = 10 * aec->mult;
 
-  float* xfw_ptr = NULL;
+  float* xfw_ptr = nullptr;
 
   // Update eBuf with echo subtractor output.
   memcpy(aec->eBuf + PART_LEN, echo_subtractor_output,
          sizeof(float) * PART_LEN);
 
   // Analysis filter banks for the echo suppressor.
   // Windowed near-end ffts.
   WindowData(fft, nearend_extended_block_lowest_band);
   ooura_fft.Fft(fft);
   StoreAsComplex(fft, dfw);
@@ skipping 268 matching lines @@
   }
 
   aec->data_dumper->DumpWav("aec_out", PART_LEN, &output_block[0][0],
                             std::min(aec->sampFreq, 16000), 1);
 }
 
 AecCore* WebRtcAec_CreateAec(int instance_count) {
   AecCore* aec = new AecCore(instance_count);
 
   if (!aec) {
-    return NULL;
+    return nullptr;
   }
   aec->nearend_buffer_size = 0;
   memset(&aec->nearend_buffer[0], 0, sizeof(aec->nearend_buffer));
   // Start the output buffer with zeros to be able to produce
   // a full output frame in the first frame.
   aec->output_buffer_size = PART_LEN - (FRAME_LEN - PART_LEN);
   memset(&aec->output_buffer[0], 0, sizeof(aec->output_buffer));
 
   aec->delay_estimator_farend =
       WebRtc_CreateDelayEstimatorFarend(PART_LEN1, kHistorySizeBlocks);
-  if (aec->delay_estimator_farend == NULL) {
+  if (aec->delay_estimator_farend == nullptr) {
     WebRtcAec_FreeAec(aec);
-    return NULL;
+    return nullptr;
   }
   // We create the delay_estimator with the same amount of maximum lookahead as
   // the delay history size (kHistorySizeBlocks) for symmetry reasons.
   aec->delay_estimator = WebRtc_CreateDelayEstimator(
       aec->delay_estimator_farend, kHistorySizeBlocks);
-  if (aec->delay_estimator == NULL) {
+  if (aec->delay_estimator == nullptr) {
     WebRtcAec_FreeAec(aec);
-    return NULL;
+    return nullptr;
   }
 #ifdef WEBRTC_ANDROID
   aec->delay_agnostic_enabled = 1;  // DA-AEC enabled by default.
   // DA-AEC assumes the system is causal from the beginning and will self adjust
   // the lookahead when shifting is required.
   WebRtc_set_lookahead(aec->delay_estimator, 0);
 #else
   aec->delay_agnostic_enabled = 0;
   WebRtc_set_lookahead(aec->delay_estimator, kLookaheadBlocks);
 #endif
@@ skipping 23 matching lines @@
 #endif
 
 #if defined(WEBRTC_HAS_NEON)
   WebRtcAec_InitAec_neon();
 #endif
 
   return aec;
 }
 
 void WebRtcAec_FreeAec(AecCore* aec) {
-  if (aec == NULL) {
+  if (aec == nullptr) {
     return;
   }
 
   WebRtc_FreeDelayEstimator(aec->delay_estimator);
   WebRtc_FreeDelayEstimatorFarend(aec->delay_estimator_farend);
 
   delete aec;
 }
 
 static void SetAdaptiveFilterStepSize(AecCore* aec) {
@@ skipping 492 matching lines @@
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   RTC_DCHECK_GE(delay, 0);
   self->system_delay = delay;
 }
 }  // namespace webrtc