replace NULL->nullptr in src/remoting.

remoting/host/audio_capturer_win.cc

 // Copyright (c) 2012 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 "remoting/host/audio_capturer_win.h"
 
 #include <windows.h>
 #include <avrt.h>
 #include <mmreg.h>
 #include <mmsystem.h>
@@ skipping 33 matching lines @@
     thread_checker_.DetachFromThread();
 }
 
 AudioCapturerWin::~AudioCapturerWin() {
 }
 
 bool AudioCapturerWin::Start(const PacketCapturedCallback& callback) {
   DCHECK(!audio_capture_client_.get());
   DCHECK(!audio_client_.get());
   DCHECK(!mm_device_.get());
-  DCHECK(static_cast<PWAVEFORMATEX>(wave_format_ex_) == NULL);
+  DCHECK(static_cast<PWAVEFORMATEX>(wave_format_ex_) == nullptr);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   callback_ = callback;
 
   // Initialize the capture timer.
   capture_timer_.reset(new base::RepeatingTimer<AudioCapturerWin>());
 
   HRESULT hr = S_OK;
 
   base::win::ScopedComPtr<IMMDeviceEnumerator> mm_device_enumerator;
   hr = mm_device_enumerator.CreateInstance(__uuidof(MMDeviceEnumerator));
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to create IMMDeviceEnumerator. Error " << hr;
     return false;
   }
 
   // Get the audio endpoint.
   hr = mm_device_enumerator->GetDefaultAudioEndpoint(eRender,
                                                      eConsole,
                                                      mm_device_.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get IMMDevice. Error " << hr;
     return false;
   }
 
   // Get an audio client.
   hr = mm_device_->Activate(__uuidof(IAudioClient),
                             CLSCTX_ALL,
-                            NULL,
+                            nullptr,
                             audio_client_.ReceiveVoid());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get an IAudioClient. Error " << hr;
     return false;
   }
 
   REFERENCE_TIME device_period;
-  hr = audio_client_->GetDevicePeriod(&device_period, NULL);
+  hr = audio_client_->GetDevicePeriod(&device_period, nullptr);
   if (FAILED(hr)) {
     LOG(ERROR) << "IAudioClient::GetDevicePeriod failed. Error " << hr;
     return false;
   }
   // We round up, if |device_period| / |k100nsPerMillisecond|
   // is not a whole number.
   int device_period_in_milliseconds =
       1 + ((device_period - 1) / k100nsPerMillisecond);
   audio_device_period_ = base::TimeDelta::FromMilliseconds(
       std::max(device_period_in_milliseconds, kMinTimerInterval));
@@ skipping 60 matching lines @@
   }
 
   // Initialize the IAudioClient.
   hr = audio_client_->Initialize(
       AUDCLNT_SHAREMODE_SHARED,
       AUDCLNT_STREAMFLAGS_LOOPBACK,
       (kMaxExpectedTimerLag + audio_device_period_.InMilliseconds()) *
       k100nsPerMillisecond,
       0,
       wave_format_ex_,
-      NULL);
+      nullptr);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to initialize IAudioClient. Error " << hr;
     return false;
   }
 
   // Get an IAudioCaptureClient.
   hr = audio_client_->GetService(__uuidof(IAudioCaptureClient),
                                  audio_capture_client_.ReceiveVoid());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get an IAudioCaptureClient. Error " << hr;
@@ skipping 18 matching lines @@
 }
 
 void AudioCapturerWin::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsStarted());
 
   capture_timer_.reset();
   mm_device_.Release();
   audio_client_.Release();
   audio_capture_client_.Release();
-  wave_format_ex_.Reset(NULL);
+  wave_format_ex_.Reset(nullptr);
 
   thread_checker_.DetachFromThread();
 }
 
 bool AudioCapturerWin::IsStarted() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return capture_timer_.get() != NULL;
+  return capture_timer_.get() != nullptr;
 }
 
 void AudioCapturerWin::DoCapture() {
   DCHECK(AudioCapturer::IsValidSampleRate(sampling_rate_));
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsStarted());
 
   // Fetch all packets from the audio capture endpoint buffer.
   HRESULT hr = S_OK;
   while (true) {
     UINT32 next_packet_size;
     HRESULT hr = audio_capture_client_->GetNextPacketSize(&next_packet_size);
     if (FAILED(hr))
       break;
 
     if (next_packet_size <= 0) {
       return;
     }
 
     BYTE* data;
     UINT32 frames;
     DWORD flags;
-    hr = audio_capture_client_->GetBuffer(&data, &frames, &flags, NULL, NULL);
+    hr = audio_capture_client_->GetBuffer(&data, &frames, &flags, nullptr,
+                                          nullptr);
     if (FAILED(hr))
       break;
 
     if ((flags & AUDCLNT_BUFFERFLAGS_SILENT) == 0 &&
         !silence_detector_.IsSilence(
             reinterpret_cast<const int16*>(data), frames * kChannels)) {
       scoped_ptr<AudioPacket> packet(new AudioPacket());
       packet->add_data(data, frames * wave_format_ex_->nBlockAlign);
       packet->set_encoding(AudioPacket::ENCODING_RAW);
       packet->set_sampling_rate(sampling_rate_);
@@ skipping 23 matching lines @@
 
 bool AudioCapturer::IsSupported() {
   return true;
 }
 
 scoped_ptr<AudioCapturer> AudioCapturer::Create() {
   return make_scoped_ptr(new AudioCapturerWin());
 }
 
 }  // namespace remoting