Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_coding/test/PCMFile.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.
  */
 
 #include "webrtc/modules/audio_coding/test/PCMFile.h"
 
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 
 #define MAX_FILE_NAME_LENGTH_BYTE 500
 
 PCMFile::PCMFile()
-    : pcm_file_(NULL),
+    : pcm_file_(nullptr),
       samples_10ms_(160),
       frequency_(16000),
       end_of_file_(false),
       auto_rewind_(false),
       rewinded_(false),
       read_stereo_(false),
       save_stereo_(false) {
   timestamp_ = (((uint32_t) rand() & 0x0000FFFF) << 16) |
       ((uint32_t) rand() & 0x0000FFFF);
 }
 
 PCMFile::PCMFile(uint32_t timestamp)
-    : pcm_file_(NULL),
+    : pcm_file_(nullptr),
       samples_10ms_(160),
       frequency_(16000),
       end_of_file_(false),
       auto_rewind_(false),
       rewinded_(false),
       read_stereo_(false),
       save_stereo_(false) {
   timestamp_ = timestamp;
 }
 
 PCMFile::~PCMFile() {
   if (pcm_file_) {
     fclose(pcm_file_);
   }
 }
 
 int16_t PCMFile::ChooseFile(std::string* file_name, int16_t max_len,
                             uint16_t* frequency_hz) {
   char tmp_name[MAX_FILE_NAME_LENGTH_BYTE];
 
-  EXPECT_TRUE(fgets(tmp_name, MAX_FILE_NAME_LENGTH_BYTE, stdin) != NULL);
+  EXPECT_TRUE(fgets(tmp_name, MAX_FILE_NAME_LENGTH_BYTE, stdin) != nullptr);
   tmp_name[MAX_FILE_NAME_LENGTH_BYTE - 1] = '\0';
   int16_t n = 0;
 
   // Removing trailing spaces.
   while ((isspace(tmp_name[n]) || iscntrl(tmp_name[n])) && (tmp_name[n] != 0)
       && (n < MAX_FILE_NAME_LENGTH_BYTE)) {
     n++;
   }
   if (n > 0) {
     memmove(tmp_name, &tmp_name[n], MAX_FILE_NAME_LENGTH_BYTE - n);
@@ skipping 13 matching lines @@
   int16_t len = (int16_t) strlen(tmp_name);
   if (len > max_len) {
     return -1;
   }
   if (len > 0) {
     std::string tmp_string(tmp_name, len + 1);
     *file_name = tmp_string;
   }
   printf("Enter the sampling frequency (in Hz) of the above file [%u]: ",
          *frequency_hz);
-  EXPECT_TRUE(fgets(tmp_name, 10, stdin) != NULL);
+  EXPECT_TRUE(fgets(tmp_name, 10, stdin) != nullptr);
   uint16_t tmp_frequency = (uint16_t) atoi(tmp_name);
   if (tmp_frequency > 0) {
     *frequency_hz = tmp_frequency;
   }
   return 0;
 }
 
 void PCMFile::Open(const std::string& file_name, uint16_t frequency,
                    const char* mode, bool auto_rewind) {
-  if ((pcm_file_ = fopen(file_name.c_str(), mode)) == NULL) {
+  if ((pcm_file_ = fopen(file_name.c_str(), mode)) == nullptr) {
     printf("Cannot open file %s.\n", file_name.c_str());
     ADD_FAILURE() << "Unable to read file";
   }
   frequency_ = frequency;
   samples_10ms_ = (uint16_t)(frequency_ / 100);
   auto_rewind_ = auto_rewind;
   end_of_file_ = false;
   rewinded_ = false;
 }
 
@@ skipping 69 matching lines @@
 
 void PCMFile::Write10MsData(int16_t* playout_buffer, size_t length_smpls) {
   if (fwrite(playout_buffer, sizeof(uint16_t), length_smpls, pcm_file_) !=
       length_smpls) {
     return;
   }
 }
 
 void PCMFile::Close() {
   fclose(pcm_file_);
-  pcm_file_ = NULL;
+  pcm_file_ = nullptr;
   blocks_read_ = 0;
 }
 
 void PCMFile::FastForward(int num_10ms_blocks) {
   const int channels = read_stereo_ ? 2 : 1;
   long num_bytes_to_move =
       num_10ms_blocks * sizeof(int16_t) * samples_10ms_ * channels;
   int error = fseek(pcm_file_, num_bytes_to_move, SEEK_CUR);
   RTC_DCHECK_EQ(error, 0);
 }
@@ skipping 14 matching lines @@
 
 void PCMFile::ReadStereo(bool is_stereo) {
   read_stereo_ = is_stereo;
 }
 
 void PCMFile::SetNum10MsBlocksToRead(int value) {
   num_10ms_blocks_to_read_ = rtc::Optional<int>(value);
 }
 
 }  // namespace webrtc