Cleanup some audio classes with C++11 shine!

media/audio/audio_output_resampler.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 "media/audio/audio_output_resampler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
@@ skipping 22 matching lines @@
                          AudioBuffersState buffers_state) OVERRIDE;
   virtual void OnError(AudioOutputStream* stream) OVERRIDE;
 
   // Sets |source_callback_|.  If this is not a new object, then Stop() must be
   // called before Start().
   void Start(AudioOutputStream::AudioSourceCallback* callback);
 
   // Clears |source_callback_| and flushes the resampler.
   void Stop();
 
-  bool started() { return source_callback_ != NULL; }
+  bool started() { return source_callback_ != nullptr; }
 
  private:
   // AudioConverter::InputCallback implementation.
   virtual double ProvideInput(AudioBus* audio_bus,
                               base::TimeDelta buffer_delay) OVERRIDE;
 
   // Ratio of input bytes to output bytes used to correct playback delay with
   // regard to buffering and resampling.
   const double io_ratio_;
 
@@ skipping 176 matching lines @@
   }
 
   return false;
 }
 
 bool AudioOutputResampler::StartStream(
     AudioOutputStream::AudioSourceCallback* callback,
     AudioOutputProxy* stream_proxy) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  OnMoreDataConverter* resampler_callback = NULL;
+  OnMoreDataConverter* resampler_callback = nullptr;
   CallbackMap::iterator it = callbacks_.find(stream_proxy);
   if (it == callbacks_.end()) {
     resampler_callback = new OnMoreDataConverter(params_, output_params_);
     callbacks_[stream_proxy] = resampler_callback;
   } else {
     resampler_callback = it->second;
   }
 
   resampler_callback->Start(callback);
   bool result = dispatcher_->StartStream(resampler_callback, stream_proxy);
@@ skipping 41 matching lines @@
   DCHECK(HasOneRef()) << "Only the AudioManager should hold a reference";
 
   dispatcher_->Shutdown();
   DCHECK(callbacks_.empty());
 }
 
 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
                                          const AudioParameters& output_params)
     : io_ratio_(static_cast<double>(input_params.GetBytesPerSecond()) /
                 output_params.GetBytesPerSecond()),
-      source_callback_(NULL),
+      source_callback_(nullptr),
       input_bytes_per_second_(input_params.GetBytesPerSecond()),
       audio_converter_(input_params, output_params, false) {}
 
 OnMoreDataConverter::~OnMoreDataConverter() {
   // Ensure Stop() has been called so we don't end up with an AudioOutputStream
   // calling back into OnMoreData() after destruction.
   CHECK(!source_callback_);
 }
 
 void OnMoreDataConverter::Start(
     AudioOutputStream::AudioSourceCallback* callback) {
   CHECK(!source_callback_);
   source_callback_ = callback;
 
   // While AudioConverter can handle multiple inputs, we're using it only with
   // a single input currently.  Eventually this may be the basis for a browser
   // side mixer.
   audio_converter_.AddInput(this);
 }
 
 void OnMoreDataConverter::Stop() {
   CHECK(source_callback_);
-  source_callback_ = NULL;
+  source_callback_ = nullptr;
   audio_converter_.RemoveInput(this);
 }
 
 int OnMoreDataConverter::OnMoreData(AudioBus* dest,
                                     AudioBuffersState buffers_state) {
   current_buffers_state_ = buffers_state;
   audio_converter_.Convert(dest);
 
   // Always return the full number of frames requested, ProvideInput()
   // will pad with silence if it wasn't able to acquire enough data.
@@ skipping 18 matching lines @@
   if (frames > 0 && frames < dest->frames())
     dest->ZeroFramesPartial(frames, dest->frames() - frames);
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   source_callback_->OnError(stream);
 }
 
 }  // namespace media