Use __func__ instead of __FUNCTION__.

media/renderers/audio_renderer_impl.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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
@@ skipping 73 matching lines @@
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&base::PowerMonitor::AddObserver,
                                       base::Unretained(monitor), this));
   }
 #endif
   // Do not add anything below this line since the above actions are only safe
   // as the last lines of the constructor.
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 #if !defined(OS_ANDROID)
   if (base::PowerMonitor::Get())
     base::PowerMonitor::Get()->RemoveObserver(this);
 #endif
 
   // If Render() is in progress, this call will wait for Render() to finish.
   // After this call, the |sink_| will not call back into |this| anymore.
   sink_->Stop();
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
 }
 
 void AudioRendererImpl::StartTicking() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!rendering_);
   rendering_ = true;
 
   base::AutoLock auto_lock(lock_);
   // Wait for an eventual call to SetPlaybackRate() to start rendering.
   if (playback_rate_ == 0) {
     DCHECK(!sink_playing_);
     return;
   }
 
   StartRendering_Locked();
 }
 
 void AudioRendererImpl::StartRendering_Locked() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPlaying);
   DCHECK(!sink_playing_);
   DCHECK_NE(playback_rate_, 0.0);
   lock_.AssertAcquired();
 
   sink_playing_ = true;
 
   base::AutoUnlock auto_unlock(lock_);
   sink_->Play();
 }
 
 void AudioRendererImpl::StopTicking() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(rendering_);
   rendering_ = false;
 
   base::AutoLock auto_lock(lock_);
   // Rendering should have already been stopped with a zero playback rate.
   if (playback_rate_ == 0) {
     DCHECK(!sink_playing_);
     return;
   }
 
   StopRendering_Locked();
 }
 
 void AudioRendererImpl::StopRendering_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPlaying);
   DCHECK(sink_playing_);
   lock_.AssertAcquired();
 
   sink_playing_ = false;
 
   base::AutoUnlock auto_unlock(lock_);
   sink_->Pause();
   stop_rendering_time_ = last_render_time_;
 }
 
 void AudioRendererImpl::SetMediaTime(base::TimeDelta time) {
-  DVLOG(1) << __FUNCTION__ << "(" << time << ")";
+  DVLOG(1) << __func__ << "(" << time << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!rendering_);
   DCHECK_EQ(state_, kFlushed);
 
   start_timestamp_ = time;
   ended_timestamp_ = kInfiniteDuration;
   last_render_time_ = stop_rendering_time_ = base::TimeTicks();
   first_packet_timestamp_ = kNoTimestamp;
@@ skipping 14 matching lines @@
       current_media_time = audio_clock_->back_timestamp();
   }
 
   // Clamp current media time to the last reported value, this prevents higher
   // level clients from seeing time go backwards based on inaccurate or spurious
   // delay values reported to the AudioClock.
   //
   // It is expected that such events are transient and will be recovered as
   // rendering continues over time.
   if (current_media_time < last_media_timestamp_) {
-    DVLOG(2) << __FUNCTION__ << ": " << last_media_timestamp_
+    DVLOG(2) << __func__ << ": " << last_media_timestamp_
              << " (clamped), actual: " << current_media_time;
     return last_media_timestamp_;
   }
 
-  DVLOG(2) << __FUNCTION__ << ": " << current_media_time;
+  DVLOG(2) << __func__ << ": " << current_media_time;
   last_media_timestamp_ = current_media_time;
   return current_media_time;
 }
 
 bool AudioRendererImpl::GetWallClockTimes(
     const std::vector<base::TimeDelta>& media_timestamps,
     std::vector<base::TimeTicks>* wall_clock_times) {
   base::AutoLock auto_lock(lock_);
   DCHECK(wall_clock_times->empty());
 
@@ skipping 48 matching lines @@
   }
 
   return is_time_moving;
 }
 
 TimeSource* AudioRendererImpl::GetTimeSource() {
   return this;
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
   DCHECK(flush_cb_.is_null());
 
   flush_cb_ = callback;
   ChangeState_Locked(kFlushing);
 
   if (pending_read_)
@@ skipping 35 matching lines @@
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
 
   // Changes in buffering state are always posted. Flush callback must only be
   // run after buffering state has been set back to nothing.
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&flush_cb_));
 }
 
 void AudioRendererImpl::StartPlaying() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
 
   ChangeState_Locked(kPlaying);
   AttemptRead_Locked();
 }
 
 void AudioRendererImpl::Initialize(DemuxerStream* stream,
                                    CdmContext* cdm_context,
                                    RendererClient* client,
                                    const PipelineStatusCB& init_cb) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(client);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(sink_.get());
 
   state_ = kInitializing;
   client_ = client;
@@ skipping 91 matching lines @@
   audio_buffer_stream_->Initialize(
       stream, base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                          weak_factory_.GetWeakPtr()),
       cdm_context, base::Bind(&AudioRendererImpl::OnStatisticsUpdate,
                               weak_factory_.GetWeakPtr()),
       base::Bind(&AudioRendererImpl::OnWaitingForDecryptionKey,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
-  DVLOG(1) << __FUNCTION__ << ": " << success;
+  DVLOG(1) << __func__ << ": " << success;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
 
   if (!success) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   if (!audio_parameters_.IsValid()) {
-    DVLOG(1) << __FUNCTION__ << ": Invalid audio parameters: "
+    DVLOG(1) << __func__ << ": Invalid audio parameters: "
              << audio_parameters_.AsHumanReadableString();
     ChangeState_Locked(kUninitialized);
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   if (expecting_config_changes_)
     buffer_converter_.reset(new AudioBufferConverter(audio_parameters_));
   splicer_.reset(new AudioSplicer(audio_parameters_.sample_rate(), media_log_));
 
@@ skipping 54 matching lines @@
 }
 
 void AudioRendererImpl::OnResume() {
   base::AutoLock auto_lock(lock_);
   is_suspending_ = false;
 }
 
 void AudioRendererImpl::DecodedAudioReady(
     AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
-  DVLOG(2) << __FUNCTION__ << "(" << status << ")";
+  DVLOG(2) << __func__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
   if (status == AudioBufferStream::ABORTED ||
       status == AudioBufferStream::DEMUXER_READ_ABORTED) {
@@ skipping 11 matching lines @@
 
   if (state_ == kFlushing) {
     ChangeState_Locked(kFlushed);
     DoFlush_Locked();
     return;
   }
 
   if (expecting_config_changes_) {
     if (last_decoded_sample_rate_ &&
         buffer->sample_rate() != last_decoded_sample_rate_) {
-      DVLOG(1) << __FUNCTION__ << " Updating audio sample_rate."
+      DVLOG(1) << __func__ << " Updating audio sample_rate."
                << " ts:" << buffer->timestamp().InMicroseconds()
                << " old:" << last_decoded_sample_rate_
                << " new:" << buffer->sample_rate();
       OnConfigChange();
     }
     last_decoded_sample_rate_ = buffer->sample_rate();
 
     DCHECK(buffer_converter_);
     buffer_converter_->AddInput(buffer);
     while (buffer_converter_->HasNextBuffer()) {
@@ skipping 134 matching lines @@
 
     case kPlaying:
       break;
   }
 
   return !pending_read_ && !received_end_of_stream_ &&
       !algorithm_->IsQueueFull();
 }
 
 void AudioRendererImpl::SetPlaybackRate(double playback_rate) {
-  DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
+  DVLOG(1) << __func__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GE(playback_rate, 0);
   DCHECK(sink_.get());
 
   base::AutoLock auto_lock(lock_);
 
   // We have two cases here:
   // Play: current_playback_rate == 0 && playback_rate != 0
   // Pause: current_playback_rate != 0 && playback_rate == 0
   double current_playback_rate = playback_rate_;
@@ skipping 17 matching lines @@
     const scoped_refptr<AudioBuffer>& buffer) {
   DCHECK_EQ(state_, kPlaying);
   return buffer.get() && !buffer->end_of_stream() &&
          (buffer->timestamp() + buffer->duration()) < start_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               uint32_t frames_delayed,
                               uint32_t frames_skipped) {
   const int frames_requested = audio_bus->frames();
-  DVLOG(4) << __FUNCTION__ << " frames_delayed:" << frames_delayed
+  DVLOG(4) << __func__ << " frames_delayed:" << frames_delayed
            << " frames_skipped:" << frames_skipped
            << " frames_requested:" << frames_requested;
 
   int frames_written = 0;
   {
     base::AutoLock auto_lock(lock_);
     last_render_time_ = tick_clock_->NowTicks();
 
     if (!stop_rendering_time_.is_null()) {
       audio_clock_->CompensateForSuspendedWrites(
@@ skipping 147 matching lines @@
         MEDIA_LOG(ERROR, media_log_)
             << "audio error during playing, status: "
             << MediaLog::PipelineStatusToString(status);
         client_->OnError(status);
       }
       return;
   }
 }
 
 void AudioRendererImpl::ChangeState_Locked(State new_state) {
-  DVLOG(1) << __FUNCTION__ << " : " << state_ << " -> " << new_state;
+  DVLOG(1) << __func__ << " : " << state_ << " -> " << new_state;
   lock_.AssertAcquired();
   state_ = new_state;
 }
 
 void AudioRendererImpl::OnNewSpliceBuffer(base::TimeDelta splice_timestamp) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   splicer_->SetSpliceTimestamp(splice_timestamp);
 }
 
 void AudioRendererImpl::OnConfigChange() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(expecting_config_changes_);
   buffer_converter_->ResetTimestampState();
   // Drain flushed buffers from the converter so the AudioSplicer receives all
   // data ahead of any OnNewSpliceBuffer() calls.  Since discontinuities should
   // only appear after config changes, AddInput() should never fail here.
   while (buffer_converter_->HasNextBuffer())
     CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer()));
 }
 
 void AudioRendererImpl::SetBufferingState_Locked(
     BufferingState buffering_state) {
-  DVLOG(1) << __FUNCTION__ << " : " << buffering_state_ << " -> "
+  DVLOG(1) << __func__ << " : " << buffering_state_ << " -> "
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media