Replacing NULL with nullptr

components/copresence/mediums/audio/audio_recorder_impl.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/copresence/mediums/audio/audio_recorder_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 35 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE, base::Bind(callback, samples));
 }
 
 }  // namespace
 
 // Public methods.
 
 AudioRecorderImpl::AudioRecorderImpl()
     : is_recording_(false),
-      stream_(NULL),
-      temp_conversion_buffer_(NULL),
+      stream_(nullptr),
+      temp_conversion_buffer_(nullptr),
       total_buffer_frames_(0),
       buffer_frame_index_(0) {
 }
 
 void AudioRecorderImpl::Initialize(
     const RecordedSamplesCallback& decode_callback) {
   decode_callback_ = decode_callback;
   media::AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&AudioRecorderImpl::InitializeOnAudioThread,
@@ skipping 57 matching lines @@
 
   stream_ = input_stream_for_testing_
                 ? input_stream_for_testing_.get()
                 : media::AudioManager::Get()->MakeAudioInputStream(
                       params, media::AudioManagerBase::kDefaultDeviceId);
 
   if (!stream_ || !stream_->Open()) {
     LOG(ERROR) << "Failed to open an input stream.";
     if (stream_) {
       stream_->Close();
-      stream_ = NULL;
+      stream_ = nullptr;
     }
     return;
   }
   stream_->SetVolume(stream_->GetMaxVolume());
 }
 
 void AudioRecorderImpl::RecordOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_ || is_recording_)
     return;
@@ skipping 12 matching lines @@
   is_recording_ = false;
 }
 
 void AudioRecorderImpl::StopAndCloseOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   if (!stream_)
     return;
 
   StopOnAudioThread();
   stream_->Close();
-  stream_ = NULL;
+  stream_ = nullptr;
 }
 
 void AudioRecorderImpl::FinalizeOnAudioThread() {
   DCHECK(media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   StopAndCloseOnAudioThread();
   delete this;
 }
 
 void AudioRecorderImpl::OnData(media::AudioInputStream* stream,
                                const media::AudioBus* source,
@@ skipping 48 matching lines @@
       FROM_HERE,
       base::Bind(&AudioRecorderImpl::StopAndCloseOnAudioThread,
                  base::Unretained(this)));
 }
 
 double AudioRecorderImpl::ProvideInput(media::AudioBus* dest,
                                        base::TimeDelta /* buffer_delay */) {
   DCHECK(temp_conversion_buffer_);
   DCHECK_LE(temp_conversion_buffer_->frames(), dest->frames());
   temp_conversion_buffer_->CopyTo(dest);
-  temp_conversion_buffer_ = NULL;
+  temp_conversion_buffer_ = nullptr;
   return 1.0;
 }
 
 void AudioRecorderImpl::FlushAudioLoopForTesting() {
   if (media::AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread())
     return;
 
   // Queue task on the audio thread, when it is executed, that means we've
   // successfully executed all the tasks before us.
   base::RunLoop rl;
   media::AudioManager::Get()->GetTaskRunner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&AudioRecorderImpl::FlushAudioLoopForTesting),
           base::Unretained(this)),
       rl.QuitClosure());
   rl.Run();
 }
 
 }  // namespace copresence