Replace NULL with nullptr in all C++ files.

webrtc/voice_engine/voe_volume_control_impl.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/voice_engine/voe_volume_control_impl.h"
 
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/channel.h"
 #include "webrtc/voice_engine/include/voe_errors.h"
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/voice_engine_impl.h"
 
 namespace webrtc {
 
 VoEVolumeControl* VoEVolumeControl::GetInterface(VoiceEngine* voiceEngine) {
-  if (NULL == voiceEngine) {
-    return NULL;
+  if (nullptr == voiceEngine) {
+    return nullptr;
   }
   VoiceEngineImpl* s = static_cast<VoiceEngineImpl*>(voiceEngine);
   s->AddRef();
   return s;
 }
 
 VoEVolumeControlImpl::VoEVolumeControlImpl(voe::SharedData* shared)
     : _shared(shared) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_shared->instance_id(), -1),
                "VoEVolumeControlImpl::VoEVolumeControlImpl() - ctor");
@@ skipping 162 matching lines @@
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (channel == -1) {
     // Mute before demultiplexing <=> affects all channels
     return _shared->transmit_mixer()->SetMute(enable);
   }
   // Mute after demultiplexing <=> affects one channel only
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
-  if (channelPtr == NULL) {
+  if (channelPtr == nullptr) {
     _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "SetInputMute() failed to locate channel");
     return -1;
   }
   return channelPtr->SetInputMute(enable);
 }
 
 int VoEVolumeControlImpl::GetInputMute(int channel, bool& enabled) {
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (channel == -1) {
     enabled = _shared->transmit_mixer()->Mute();
   } else {
     voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
     voe::Channel* channelPtr = ch.channel();
-    if (channelPtr == NULL) {
+    if (channelPtr == nullptr) {
       _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                             "SetInputMute() failed to locate channel");
       return -1;
     }
     enabled = channelPtr->InputMute();
   }
   return 0;
 }
 
 int VoEVolumeControlImpl::GetSpeechInputLevel(unsigned int& level) {
@@ skipping 10 matching lines @@
                                                unsigned int& level) {
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (channel == -1) {
     return _shared->output_mixer()->GetSpeechOutputLevel((uint32_t&)level);
   } else {
     voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
     voe::Channel* channelPtr = ch.channel();
-    if (channelPtr == NULL) {
+    if (channelPtr == nullptr) {
       _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                             "GetSpeechOutputLevel() failed to locate channel");
       return -1;
     }
     channelPtr->GetSpeechOutputLevel((uint32_t&)level);
   }
   return 0;
 }
 
 int VoEVolumeControlImpl::GetSpeechInputLevelFullRange(unsigned int& level) {
@@ skipping 11 matching lines @@
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (channel == -1) {
     return _shared->output_mixer()->GetSpeechOutputLevelFullRange(
         (uint32_t&)level);
   } else {
     voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
     voe::Channel* channelPtr = ch.channel();
-    if (channelPtr == NULL) {
+    if (channelPtr == nullptr) {
       _shared->SetLastError(
           VE_CHANNEL_NOT_VALID, kTraceError,
           "GetSpeechOutputLevelFullRange() failed to locate channel");
       return -1;
     }
     channelPtr->GetSpeechOutputLevelFullRange((uint32_t&)level);
   }
   return 0;
 }
 
 int VoEVolumeControlImpl::SetChannelOutputVolumeScaling(int channel,
                                                         float scaling) {
   WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
                "SetChannelOutputVolumeScaling(channel=%d, scaling=%3.2f)",
                channel, scaling);
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   if (scaling < kMinOutputVolumeScaling || scaling > kMaxOutputVolumeScaling) {
     _shared->SetLastError(VE_INVALID_ARGUMENT, kTraceError,
                           "SetChannelOutputVolumeScaling() invalid parameter");
     return -1;
   }
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
-  if (channelPtr == NULL) {
+  if (channelPtr == nullptr) {
     _shared->SetLastError(
         VE_CHANNEL_NOT_VALID, kTraceError,
         "SetChannelOutputVolumeScaling() failed to locate channel");
     return -1;
   }
   return channelPtr->SetChannelOutputVolumeScaling(scaling);
 }
 
 int VoEVolumeControlImpl::GetChannelOutputVolumeScaling(int channel,
                                                         float& scaling) {
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
-  if (channelPtr == NULL) {
+  if (channelPtr == nullptr) {
     _shared->SetLastError(
         VE_CHANNEL_NOT_VALID, kTraceError,
         "GetChannelOutputVolumeScaling() failed to locate channel");
     return -1;
   }
   return channelPtr->GetChannelOutputVolumeScaling(scaling);
 }
 
 int VoEVolumeControlImpl::SetOutputVolumePan(int channel,
                                              float left,
@@ skipping 21 matching lines @@
     return -1;
   }
 
   if (channel == -1) {
     // Master balance (affectes the signal after output mixing)
     return _shared->output_mixer()->SetOutputVolumePan(left, right);
   }
   // Per-channel balance (affects the signal before output mixing)
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
-  if (channelPtr == NULL) {
+  if (channelPtr == nullptr) {
     _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "SetOutputVolumePan() failed to locate channel");
     return -1;
   }
   return channelPtr->SetOutputVolumePan(left, right);
 }
 
 int VoEVolumeControlImpl::GetOutputVolumePan(int channel,
                                              float& left,
                                              float& right) {
   if (!_shared->statistics().Initialized()) {
     _shared->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   bool available(false);
   _shared->audio_device()->StereoPlayoutIsAvailable(&available);
   if (!available) {
     _shared->SetLastError(VE_FUNC_NO_STEREO, kTraceError,
                           "GetOutputVolumePan() stereo playout not supported");
     return -1;
   }
 
   if (channel == -1) {
     return _shared->output_mixer()->GetOutputVolumePan(left, right);
   }
   voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
-  if (channelPtr == NULL) {
+  if (channelPtr == nullptr) {
     _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "GetOutputVolumePan() failed to locate channel");
     return -1;
   }
   return channelPtr->GetOutputVolumePan(left, right);
 }
 
 }  // namespace webrtc