Use __func__ instead of __FUNCTION__.

media/base/pipeline_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/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 539 matching lines @@
   DCHECK(shared_state_.renderer);
 
   base::TimeDelta currTime = (state_ == kPlaying)
                                  ? shared_state_.renderer->GetMediaTime()
                                  : start_timestamp_;
   demuxer_->OnSelectedVideoTrackChanged(selectedTrackId, currTime);
 }
 
 void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
     const PipelineStatistics& stats) {
-  DVLOG(3) << __FUNCTION__;
+  DVLOG(3) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.statistics.audio_bytes_decoded += stats.audio_bytes_decoded;
   shared_state_.statistics.video_bytes_decoded += stats.video_bytes_decoded;
   shared_state_.statistics.video_frames_decoded += stats.video_frames_decoded;
   shared_state_.statistics.video_frames_dropped += stats.video_frames_dropped;
   shared_state_.statistics.audio_memory_usage += stats.audio_memory_usage;
   shared_state_.statistics.video_memory_usage += stats.video_memory_usage;
 }
 
 void PipelineImpl::RendererWrapper::OnBufferingStateChange(
     BufferingState state) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
-  DVLOG(2) << __FUNCTION__ << "(" << state << ") ";
+  DVLOG(2) << __func__ << "(" << state << ") ";
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::OnBufferingStateChange, weak_pipeline_, state));
 }
 
 void PipelineImpl::RendererWrapper::OnWaitingForDecryptionKey() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   main_task_runner_->PostTask(
@@ skipping 127 matching lines @@
   }
 
   // Seek demuxer.
   bound_fns.Push(
       base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void PipelineImpl::RendererWrapper::DoStop(const base::Closure& done_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopping);
   DCHECK(!pending_callbacks_.get());
 
   DestroyRenderer();
   text_renderer_.reset();
 
   if (demuxer_) {
     demuxer_->Stop();
     demuxer_ = NULL;
@@ skipping 191 matching lines @@
 
 PipelineImpl::PipelineImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     MediaLog* media_log)
     : media_task_runner_(media_task_runner),
       media_log_(media_log),
       client_(nullptr),
       playback_rate_(kDefaultPlaybackRate),
       volume_(kDefaultVolume),
       weak_factory_(this) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   renderer_wrapper_.reset(new RendererWrapper(media_task_runner_, media_log_));
 }
 
 PipelineImpl::~PipelineImpl() {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!client_) << "Stop() must complete before destroying object";
   DCHECK(seek_cb_.is_null());
   DCHECK(suspend_cb_.is_null());
   DCHECK(!weak_factory_.HasWeakPtrs());
 
   // RendererWrapper is deleted on the media thread.
   media_task_runner_->DeleteSoon(FROM_HERE, renderer_wrapper_.release());
 }
 
 void PipelineImpl::Start(Demuxer* demuxer,
                          std::unique_ptr<Renderer> renderer,
                          Client* client,
                          const PipelineStatusCB& seek_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(demuxer);
   DCHECK(renderer);
   DCHECK(client);
   DCHECK(!seek_cb.is_null());
 
   DCHECK(!client_);
   DCHECK(seek_cb_.is_null());
   client_ = client;
   seek_cb_ = seek_cb;
 
   std::unique_ptr<TextRenderer> text_renderer;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableInbandTextTracks)) {
     text_renderer.reset(new TextRenderer(
         media_task_runner_,
         BindToCurrentLoop(base::Bind(&PipelineImpl::OnAddTextTrack,
                                      weak_factory_.GetWeakPtr()))));
   }
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::Start,
                  base::Unretained(renderer_wrapper_.get()), demuxer,
                  base::Passed(&renderer), base::Passed(&text_renderer),
                  weak_factory_.GetWeakPtr()));
 }
 
 void PipelineImpl::Stop() {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!IsRunning()) {
     DVLOG(2) << "Media pipeline isn't running. Ignoring Stop()";
     return;
   }
 
   if (media_task_runner_->BelongsToCurrentThread()) {
     // This path is executed by unittests that share media and main threads.
     base::Closure stop_cb = base::Bind(&base::DoNothing);
@@ skipping 30 matching lines @@
   seek_cb_.Reset();
   suspend_cb_.Reset();
   client_ = nullptr;
 
   // Invalidate self weak pointers effectively canceling all pending
   // notifications in the message queue.
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void PipelineImpl::Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb) {
-  DVLOG(2) << __FUNCTION__ << " to " << time.InMicroseconds();
+  DVLOG(2) << __func__ << " to " << time.InMicroseconds();
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!seek_cb.is_null());
 
   if (!IsRunning()) {
     DLOG(ERROR) << "Media pipeline isn't running. Ignoring Seek().";
     return;
   }
 
   DCHECK(seek_cb_.is_null());
   seek_cb_ = seek_cb;
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RendererWrapper::Seek,
                             base::Unretained(renderer_wrapper_.get()), time));
 }
 
 void PipelineImpl::Suspend(const PipelineStatusCB& suspend_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(!suspend_cb.is_null());
 
   DCHECK(IsRunning());
   DCHECK(suspend_cb_.is_null());
   suspend_cb_ = suspend_cb;
 
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RendererWrapper::Suspend,
                             base::Unretained(renderer_wrapper_.get())));
 }
 
 void PipelineImpl::Resume(std::unique_ptr<Renderer> renderer,
                           base::TimeDelta time,
                           const PipelineStatusCB& seek_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(renderer);
   DCHECK(!seek_cb.is_null());
 
   DCHECK(IsRunning());
   DCHECK(seek_cb_.is_null());
   seek_cb_ = seek_cb;
 
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RendererWrapper::Resume,
                             base::Unretained(renderer_wrapper_.get()),
                             base::Passed(&renderer), time));
 }
 
 bool PipelineImpl::IsRunning() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !!client_;
 }
 
 double PipelineImpl::GetPlaybackRate() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return playback_rate_;
 }
 
 void PipelineImpl::SetPlaybackRate(double playback_rate) {
-  DVLOG(2) << __FUNCTION__ << "(" << playback_rate << ")";
+  DVLOG(2) << __func__ << "(" << playback_rate << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (playback_rate < 0.0)
     return;
 
   playback_rate_ = playback_rate;
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::SetPlaybackRate,
                  base::Unretained(renderer_wrapper_.get()), playback_rate_));
 }
 
 float PipelineImpl::GetVolume() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return volume_;
 }
 
 void PipelineImpl::SetVolume(float volume) {
-  DVLOG(2) << __FUNCTION__ << "(" << volume << ")";
+  DVLOG(2) << __func__ << "(" << volume << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (volume < 0.0f || volume > 1.0f)
     return;
 
   volume_ = volume;
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::SetVolume,
                  base::Unretained(renderer_wrapper_.get()), volume_));
@@ skipping 19 matching lines @@
   return renderer_wrapper_->DidLoadingProgress();
 }
 
 PipelineStatistics PipelineImpl::GetStatistics() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return renderer_wrapper_->GetStatistics();
 }
 
 void PipelineImpl::SetCdm(CdmContext* cdm_context,
                           const CdmAttachedCB& cdm_attached_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(cdm_context);
   DCHECK(!cdm_attached_cb.is_null());
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::SetCdm,
                  base::Unretained(renderer_wrapper_.get()), cdm_context,
                  media::BindToCurrentLoop(cdm_attached_cb)));
 }
@@ skipping 16 matching lines @@
     RETURN_STRING(kSuspended);
     RETURN_STRING(kResuming);
   }
   NOTREACHED();
   return "INVALID";
 }
 
 #undef RETURN_STRING
 
 void PipelineImpl::OnError(PipelineStatus error) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
   DCHECK(IsRunning());
 
   // If the error happens during starting/seeking/suspending/resuming,
   // report the error via the completion callback for those tasks.
   // Else report error via the client interface.
   if (!seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(error);
   } else if (!suspend_cb_.is_null()) {
     base::ResetAndReturn(&suspend_cb_).Run(error);
   } else {
     DCHECK(client_);
     client_->OnError(error);
   }
 
   // Any kind of error stops the pipeline.
   Stop();
 }
 
 void PipelineImpl::OnEnded() {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnEnded();
 }
 
 void PipelineImpl::OnMetadata(PipelineMetadata metadata) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnMetadata(metadata);
 }
 
 void PipelineImpl::OnBufferingStateChange(BufferingState state) {
-  DVLOG(2) << __FUNCTION__ << "(" << state << ")";
+  DVLOG(2) << __func__ << "(" << state << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnBufferingStateChange(state);
 }
 
 void PipelineImpl::OnDurationChange(base::TimeDelta duration) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   duration_ = duration;
 
   DCHECK(client_);
   client_->OnDurationChange();
 }
 
 void PipelineImpl::OnAddTextTrack(const TextTrackConfig& config,
                                   const AddTextTrackDoneCB& done_cb) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnAddTextTrack(config, done_cb);
 }
 
 void PipelineImpl::OnWaitingForDecryptionKey() {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnWaitingForDecryptionKey();
 }
 
 void PipelineImpl::OnVideoNaturalSizeChange(const gfx::Size& size) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void PipelineImpl::OnVideoOpacityChange(bool opaque) {
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(client_);
   client_->OnVideoOpacityChange(opaque);
 }
 
 void PipelineImpl::OnSeekDone(base::TimeDelta start_time) {
-  DVLOG(3) << __FUNCTION__ << "(" << start_time.InMicroseconds() << ")";
+  DVLOG(3) << __func__ << "(" << start_time.InMicroseconds() << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!seek_cb_.is_null());
   base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 }
 
 void PipelineImpl::OnSuspendDone(base::TimeDelta suspend_time) {
-  DVLOG(3) << __FUNCTION__ << "(" << suspend_time.InMicroseconds() << ")";
+  DVLOG(3) << __func__ << "(" << suspend_time.InMicroseconds() << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media