Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_coding/test/opus_test.cc

 /*
  *  Copyright (c) 2013 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 11 matching lines @@
 #include "webrtc/modules/audio_coding/test/utility.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 OpusTest::OpusTest()
     : acm_receiver_(AudioCodingModule::Create(0)),
-      channel_a2b_(NULL),
+      channel_a2b_(nullptr),
       counter_(0),
       payload_type_(255),
       rtp_timestamp_(0) {}
 
 OpusTest::~OpusTest() {
-  if (channel_a2b_ != NULL) {
+  if (channel_a2b_ != nullptr) {
     delete channel_a2b_;
-    channel_a2b_ = NULL;
+    channel_a2b_ = nullptr;
   }
-  if (opus_mono_encoder_ != NULL) {
+  if (opus_mono_encoder_ != nullptr) {
     WebRtcOpus_EncoderFree(opus_mono_encoder_);
-    opus_mono_encoder_ = NULL;
+    opus_mono_encoder_ = nullptr;
   }
-  if (opus_stereo_encoder_ != NULL) {
+  if (opus_stereo_encoder_ != nullptr) {
     WebRtcOpus_EncoderFree(opus_stereo_encoder_);
-    opus_stereo_encoder_ = NULL;
+    opus_stereo_encoder_ = nullptr;
   }
-  if (opus_mono_decoder_ != NULL) {
+  if (opus_mono_decoder_ != nullptr) {
     WebRtcOpus_DecoderFree(opus_mono_decoder_);
-    opus_mono_decoder_ = NULL;
+    opus_mono_decoder_ = nullptr;
   }
-  if (opus_stereo_decoder_ != NULL) {
+  if (opus_stereo_decoder_ != nullptr) {
     WebRtcOpus_DecoderFree(opus_stereo_decoder_);
-    opus_stereo_decoder_ = NULL;
+    opus_stereo_decoder_ = nullptr;
   }
 }
 
 void OpusTest::Perform() {
 #ifndef WEBRTC_CODEC_OPUS
   // Opus isn't defined, exit.
   return;
 #else
   uint16_t frequency_hz;
   size_t audio_channels;
@@ skipping 13 matching lines @@
   // Create Opus encoders for mono and stereo.
   ASSERT_GT(WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1, 0), -1);
   ASSERT_GT(WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2, 1), -1);
 
   // Create Opus decoders for mono and stereo for stand-alone testing of Opus.
   ASSERT_GT(WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1), -1);
   ASSERT_GT(WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2), -1);
   WebRtcOpus_DecoderInit(opus_mono_decoder_);
   WebRtcOpus_DecoderInit(opus_stereo_decoder_);
 
-  ASSERT_TRUE(acm_receiver_.get() != NULL);
+  ASSERT_TRUE(acm_receiver_.get() != nullptr);
   EXPECT_EQ(0, acm_receiver_->InitializeReceiver());
 
   // Register Opus stereo as receiving codec.
   CodecInst opus_codec_param;
   int codec_id = acm_receiver_->Codec("opus", 48000, 2);
   EXPECT_EQ(0, acm_receiver_->Codec(codec_id, &opus_codec_param));
   payload_type_ = opus_codec_param.pltype;
   EXPECT_EQ(true,
             acm_receiver_->RegisterReceiveCodec(
                 opus_codec_param.pltype, CodecInstToSdp(opus_codec_param)));
@@ skipping 218 matching lines @@
                 &out_audio[decoded_samples * channels], &audio_type);
           } else {
             decoded_samples += WebRtcOpus_DecodePlc(
                 opus_stereo_decoder_, &out_audio[decoded_samples * channels],
                 1);
           }
         }
 
         // Send data to the channel. "channel" will handle the loss simulation.
         channel->SendData(kAudioFrameSpeech, payload_type_, rtp_timestamp_,
-                          bitstream, bitstream_len_byte, NULL);
+                          bitstream, bitstream_len_byte, nullptr);
         if (first_packet) {
           first_packet = false;
           start_time_stamp = rtp_timestamp_;
         }
         rtp_timestamp_ += static_cast<uint32_t>(frame_length);
         read_samples += frame_length * channels;
       }
       if (read_samples == written_samples) {
         read_samples = 0;
         written_samples = 0;
@@ skipping 42 matching lines @@
   out_file_.Open(file_name, 48000, "wb");
   file_stream.str("");
   file_name = file_stream.str();
   file_stream << webrtc::test::OutputPath() << "opusstandalone_out_"
       << test_number << ".pcm";
   file_name = file_stream.str();
   out_file_standalone_.Open(file_name, 48000, "wb");
 }
 
 }  // namespace webrtc