Use __func__ instead of __FUNCTION__.

media/renderers/renderer_impl.cc

 // Copyright 2014 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/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 68 matching lines @@
       video_buffering_state_(BUFFERING_HAVE_NOTHING),
       audio_ended_(false),
       video_ended_(false),
       cdm_context_(nullptr),
       underflow_disabled_for_testing_(false),
       clockless_video_playback_enabled_for_testing_(false),
       video_underflow_threshold_(
           base::TimeDelta::FromMilliseconds(kDefaultVideoUnderflowThresholdMs)),
       weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
 
   // TODO(dalecurtis): Remove once experiments for http://crbug.com/470940 are
   // complete.
   int threshold_ms = 0;
   std::string threshold_ms_str(
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kVideoUnderflowThresholdMs));
   if (base::StringToInt(threshold_ms_str, &threshold_ms) && threshold_ms > 0) {
     video_underflow_threshold_ =
         base::TimeDelta::FromMilliseconds(threshold_ms);
   }
 }
 
 RendererImpl::~RendererImpl() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Tear down in opposite order of construction as |video_renderer_| can still
   // need |time_source_| (which can be |audio_renderer_|) to be alive.
   video_renderer_.reset();
   audio_renderer_.reset();
 
   if (!init_cb_.is_null()) {
     FinishInitialization(PIPELINE_ERROR_ABORT);
   } else if (!flush_cb_.is_null()) {
     base::ResetAndReturn(&flush_cb_).Run();
   }
 }
 
 void RendererImpl::Initialize(DemuxerStreamProvider* demuxer_stream_provider,
                               RendererClient* client,
                               const PipelineStatusCB& init_cb) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(!init_cb.is_null());
   DCHECK(client);
   DCHECK(demuxer_stream_provider->GetStream(DemuxerStream::AUDIO) ||
          demuxer_stream_provider->GetStream(DemuxerStream::VIDEO));
 
   client_ = client;
   demuxer_stream_provider_ = demuxer_stream_provider;
   init_cb_ = init_cb;
@@ skipping 13 matching lines @@
     state_ = STATE_INIT_PENDING_CDM;
     return;
   }
 
   state_ = STATE_INITIALIZING;
   InitializeAudioRenderer();
 }
 
 void RendererImpl::SetCdm(CdmContext* cdm_context,
                           const CdmAttachedCB& cdm_attached_cb) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(cdm_context);
 
   if (cdm_context_) {
     DVLOG(1) << "Switching CDM not supported.";
     cdm_attached_cb.Run(false);
     return;
   }
 
   cdm_context_ = cdm_context;
 
   if (state_ != STATE_INIT_PENDING_CDM) {
     cdm_attached_cb.Run(true);
     return;
   }
 
   DCHECK(!init_cb_.is_null());
   state_ = STATE_INITIALIZING;
   // |cdm_attached_cb| will be fired after initialization finishes.
   pending_cdm_attached_cb_ = cdm_attached_cb;
 
   InitializeAudioRenderer();
 }
 
 void RendererImpl::Flush(const base::Closure& flush_cb) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(flush_cb_.is_null());
 
   if (state_ != STATE_PLAYING) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
   }
 
   flush_cb_ = flush_cb;
   state_ = STATE_FLUSHING;
 
   if (time_ticking_)
     PausePlayback();
 
   FlushAudioRenderer();
 }
 
 void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != STATE_PLAYING) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
   }
 
   time_source_->SetMediaTime(time);
 
   if (audio_renderer_)
     audio_renderer_->StartPlaying();
   if (video_renderer_)
     video_renderer_->StartPlayingFrom(time);
 }
 
 void RendererImpl::RestartStreamPlayback(DemuxerStream* stream,
                                          base::TimeDelta time) {
-  DVLOG(1) << __FUNCTION__ << " stream=" << stream
-           << " time=" << time.InSecondsF();
+  DVLOG(1) << __func__ << " stream=" << stream << " time=" << time.InSecondsF();
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != STATE_PLAYING)
     return;
   if (stream->type() == DemuxerStream::VIDEO) {
     DCHECK(video_renderer_);
     if (restarting_video_)
       return;
     restarting_video_ = true;
     video_renderer_->Flush(
         base::Bind(&RendererImpl::RestartVideoRenderer, weak_this_, time));
@@ skipping 10 matching lines @@
       time_ticking_ = false;
       time_source_->StopTicking();
     }
     audio_renderer_->Flush(
         base::Bind(&RendererImpl::RestartAudioRenderer, weak_this_, time));
   }
 }
 
 void RendererImpl::RestartVideoRenderer(base::TimeDelta time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   video_ended_ = false;
   if (state_ == STATE_PLAYING) {
     DCHECK(video_renderer_);
     video_renderer_->StartPlayingFrom(time);
   }
 }
 
 void RendererImpl::RestartAudioRenderer(base::TimeDelta time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DVLOG(2) << __FUNCTION__;
+  DVLOG(2) << __func__;
   audio_ended_ = false;
   if (state_ == STATE_PLAYING) {
     DCHECK(time_source_);
     DCHECK(audio_renderer_);
     audio_renderer_->StartPlaying();
   }
 }
 
 void RendererImpl::SetPlaybackRate(double playback_rate) {
-  DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
+  DVLOG(1) << __func__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
   if (state_ != STATE_PLAYING)
     return;
 
   time_source_->SetPlaybackRate(playback_rate);
 
   const double old_rate = playback_rate_;
   playback_rate_ = playback_rate;
   if (!time_ticking_ || !video_renderer_)
     return;
 
   if (old_rate == 0 && playback_rate > 0)
     video_renderer_->OnTimeStateChanged(true);
   else if (old_rate > 0 && playback_rate == 0)
     video_renderer_->OnTimeStateChanged(false);
 }
 
 void RendererImpl::SetVolume(float volume) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_)
     audio_renderer_->SetVolume(volume);
 }
 
 base::TimeDelta RendererImpl::GetMediaTime() {
   // No BelongsToCurrentThread() checking because this can be called from other
   // threads.
   return time_source_->CurrentMediaTime();
 }
 
 bool RendererImpl::HasAudio() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return audio_renderer_ != NULL;
 }
 
 bool RendererImpl::HasVideo() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return video_renderer_ != NULL;
 }
 
 void RendererImpl::DisableUnderflowForTesting() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   underflow_disabled_for_testing_ = true;
 }
 
 void RendererImpl::EnableClocklessVideoPlaybackForTesting() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(underflow_disabled_for_testing_)
       << "Underflow must be disabled for clockless video playback";
 
   clockless_video_playback_enabled_for_testing_ = true;
 }
 
 bool RendererImpl::GetWallClockTimes(
     const std::vector<base::TimeDelta>& media_timestamps,
@@ skipping 36 matching lines @@
 void RendererImpl::FinishInitialization(PipelineStatus status) {
   DCHECK(!init_cb_.is_null());
 
   if (!pending_cdm_attached_cb_.is_null())
     base::ResetAndReturn(&pending_cdm_attached_cb_).Run(status == PIPELINE_OK);
 
   base::ResetAndReturn(&init_cb_).Run(status);
 }
 
 void RendererImpl::InitializeAudioRenderer() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(!init_cb_.is_null());
 
   PipelineStatusCB done_cb =
       base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 
   if (!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO)) {
     audio_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
   audio_renderer_client_.reset(
       new RendererClientInternal(DemuxerStream::AUDIO, this));
   // Note: After the initialization of a renderer, error events from it may
   // happen at any time and all future calls must guard against STATE_ERROR.
   audio_renderer_->Initialize(
       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO), cdm_context_,
       audio_renderer_client_.get(), done_cb);
 }
 
 void RendererImpl::OnAudioRendererInitializeDone(PipelineStatus status) {
-  DVLOG(1) << __FUNCTION__ << ": " << status;
+  DVLOG(1) << __func__ << ": " << status;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // OnError() may be fired at any time by the renderers, even if they thought
   // they initialized successfully (due to delayed output device setup).
   if (state_ != STATE_INITIALIZING) {
     DCHECK(init_cb_.is_null());
     audio_renderer_.reset();
     return;
   }
 
   if (status != PIPELINE_OK) {
     FinishInitialization(status);
     return;
   }
 
   DCHECK(!init_cb_.is_null());
   InitializeVideoRenderer();
 }
 
 void RendererImpl::InitializeVideoRenderer() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(!init_cb_.is_null());
 
   PipelineStatusCB done_cb =
       base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 
   if (!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO)) {
     video_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
   video_renderer_client_.reset(
       new RendererClientInternal(DemuxerStream::VIDEO, this));
   video_renderer_->Initialize(
       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO), cdm_context_,
       video_renderer_client_.get(),
       base::Bind(&RendererImpl::GetWallClockTimes, base::Unretained(this)),
       done_cb);
 }
 
 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
-  DVLOG(1) << __FUNCTION__ << ": " << status;
+  DVLOG(1) << __func__ << ": " << status;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // OnError() may be fired at any time by the renderers, even if they thought
   // they initialized successfully (due to delayed output device setup).
   if (state_ != STATE_INITIALIZING) {
     DCHECK(init_cb_.is_null());
     audio_renderer_.reset();
     video_renderer_.reset();
     return;
   }
@@ skipping 13 matching lines @@
   }
 
   state_ = STATE_PLAYING;
   DCHECK(time_source_);
   DCHECK(audio_renderer_ || video_renderer_);
 
   FinishInitialization(PIPELINE_OK);
 }
 
 void RendererImpl::FlushAudioRenderer() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
   if (!audio_renderer_) {
     OnAudioRendererFlushDone();
     return;
   }
 
   audio_renderer_->Flush(
       base::Bind(&RendererImpl::OnAudioRendererFlushDone, weak_this_));
 }
 
 void RendererImpl::OnAudioRendererFlushDone() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ == STATE_ERROR) {
     DCHECK(flush_cb_.is_null());
     return;
   }
 
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
   // If we had a deferred video renderer underflow prior to the flush, it should
   // have been cleared by the audio renderer changing to BUFFERING_HAVE_NOTHING.
   DCHECK(deferred_video_underflow_cb_.IsCancelled());
 
   DCHECK_EQ(audio_buffering_state_, BUFFERING_HAVE_NOTHING);
   audio_ended_ = false;
   FlushVideoRenderer();
 }
 
 void RendererImpl::FlushVideoRenderer() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
   if (!video_renderer_) {
     OnVideoRendererFlushDone();
     return;
   }
 
   video_renderer_->Flush(
       base::Bind(&RendererImpl::OnVideoRendererFlushDone, weak_this_));
 }
 
 void RendererImpl::OnVideoRendererFlushDone() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ == STATE_ERROR) {
     DCHECK(flush_cb_.is_null());
     return;
   }
 
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
@@ skipping 23 matching lines @@
 }
 
 bool RendererImpl::HandleRestartedStreamBufferingChanges(
     DemuxerStream::Type type,
     BufferingState new_buffering_state) {
   // When restarting playback we want to defer the BUFFERING_HAVE_NOTHING for
   // the stream being restarted, to allow continuing uninterrupted playback on
   // the other stream.
   if (type == DemuxerStream::VIDEO && restarting_video_) {
     if (new_buffering_state == BUFFERING_HAVE_ENOUGH) {
-      DVLOG(1) << __FUNCTION__ << " Got BUFFERING_HAVE_ENOUGH for video stream,"
-                                  " resuming playback.";
+      DVLOG(1) << __func__ << " Got BUFFERING_HAVE_ENOUGH for video stream,"
+                              " resuming playback.";
       restarting_video_ = false;
       if (state_ == STATE_PLAYING &&
           !deferred_video_underflow_cb_.IsCancelled()) {
         // If deferred_video_underflow_cb_ wasn't triggered, then audio should
         // still be playing, we only need to unpause the video stream.
         DVLOG(4) << "deferred_video_underflow_cb_.Cancel()";
         deferred_video_underflow_cb_.Cancel();
         video_buffering_state_ = new_buffering_state;
         if (playback_rate_ > 0)
           video_renderer_->OnTimeStateChanged(true);
         return true;
       }
     }
     // We don't handle the BUFFERING_HAVE_NOTHING case explicitly here, since
     // the existing logic for deferring video underflow reporting in
     // OnBufferingStateChange is exactly what we need. So fall through to the
     // regular video underflow handling path in OnBufferingStateChange.
   }
 
   if (type == DemuxerStream::AUDIO && restarting_audio_) {
     if (new_buffering_state == BUFFERING_HAVE_NOTHING) {
       if (deferred_video_underflow_cb_.IsCancelled() &&
           deferred_audio_restart_underflow_cb_.IsCancelled()) {
-        DVLOG(1) << __FUNCTION__ << " Deferring BUFFERING_HAVE_NOTHING for "
-                                    "audio stream which is being restarted.";
+        DVLOG(1) << __func__ << " Deferring BUFFERING_HAVE_NOTHING for "
+                                "audio stream which is being restarted.";
         audio_buffering_state_ = new_buffering_state;
         deferred_audio_restart_underflow_cb_.Reset(
             base::Bind(&RendererImpl::OnBufferingStateChange, weak_this_, type,
                        new_buffering_state));
         task_runner_->PostDelayedTask(
             FROM_HERE, deferred_audio_restart_underflow_cb_.callback(),
             base::TimeDelta::FromMilliseconds(
                 kAudioRestartUnderflowThresholdMs));
         return true;
       }
       // Cancel the deferred callback and report the underflow immediately.
       DVLOG(4) << "deferred_audio_restart_underflow_cb_.Cancel()";
       deferred_audio_restart_underflow_cb_.Cancel();
     } else if (new_buffering_state == BUFFERING_HAVE_ENOUGH) {
-      DVLOG(1) << __FUNCTION__ << " Got BUFFERING_HAVE_ENOUGH for audio stream,"
-                                  " resuming playback.";
+      DVLOG(1) << __func__ << " Got BUFFERING_HAVE_ENOUGH for audio stream,"
+                              " resuming playback.";
       deferred_audio_restart_underflow_cb_.Cancel();
       // Now that we have decoded enough audio, pause playback momentarily to
       // ensure video renderer is synchronised with audio.
       PausePlayback();
       restarting_audio_ = false;
     }
   }
   return false;
 }
 
 void RendererImpl::OnBufferingStateChange(DemuxerStream::Type type,
                                           BufferingState new_buffering_state) {
   DCHECK((type == DemuxerStream::AUDIO) || (type == DemuxerStream::VIDEO));
   BufferingState* buffering_state = type == DemuxerStream::AUDIO
                                         ? &audio_buffering_state_
                                         : &video_buffering_state_;
 
-  DVLOG(1) << __FUNCTION__
-           << (type == DemuxerStream::AUDIO ? " audio " : " video ")
+  DVLOG(1) << __func__ << (type == DemuxerStream::AUDIO ? " audio " : " video ")
            << BufferingStateStr(*buffering_state) << " -> "
            << BufferingStateStr(new_buffering_state);
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   bool was_waiting_for_enough_data = WaitingForEnoughData();
 
   if (restarting_audio_ || restarting_video_) {
     if (HandleRestartedStreamBufferingChanges(type, new_buffering_state))
       return;
   }
 
   // When audio is present and has enough data, defer video underflow callbacks
   // for some time to avoid unnecessary glitches in audio; see
   // http://crbug.com/144683#c53.
   if (audio_renderer_ && type == DemuxerStream::VIDEO &&
       state_ == STATE_PLAYING) {
     if (video_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
         audio_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
         new_buffering_state == BUFFERING_HAVE_NOTHING &&
         deferred_video_underflow_cb_.IsCancelled()) {
-      DVLOG(4) << __FUNCTION__ << " Deferring HAVE_NOTHING for video stream.";
+      DVLOG(4) << __func__ << " Deferring HAVE_NOTHING for video stream.";
       deferred_video_underflow_cb_.Reset(
           base::Bind(&RendererImpl::OnBufferingStateChange,
                      weak_factory_.GetWeakPtr(), type, new_buffering_state));
       task_runner_->PostDelayedTask(FROM_HERE,
                                     deferred_video_underflow_cb_.callback(),
                                     video_underflow_threshold_);
       return;
     }
 
     DVLOG(4) << "deferred_video_underflow_cb_.Cancel()";
@@ skipping 36 matching lines @@
   if (state_ != STATE_PLAYING)
     return false;
   if (audio_renderer_ && audio_buffering_state_ != BUFFERING_HAVE_ENOUGH)
     return true;
   if (video_renderer_ && video_buffering_state_ != BUFFERING_HAVE_ENOUGH)
     return true;
   return false;
 }
 
 void RendererImpl::PausePlayback() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   switch (state_) {
     case STATE_PLAYING:
       DCHECK(PlaybackHasEnded() || WaitingForEnoughData() || restarting_audio_)
           << "Playback should only pause due to ending or underflowing or"
              " when restarting audio stream";
 
       break;
 
     case STATE_FLUSHING:
@@ skipping 13 matching lines @@
 
   if (time_ticking_) {
     time_ticking_ = false;
     time_source_->StopTicking();
   }
   if (playback_rate_ > 0 && video_renderer_)
     video_renderer_->OnTimeStateChanged(false);
 }
 
 void RendererImpl::StartPlayback() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_PLAYING);
   DCHECK(!time_ticking_);
   DCHECK(!WaitingForEnoughData());
 
   time_ticking_ = true;
   time_source_->StartTicking();
   if (playback_rate_ > 0 && video_renderer_)
     video_renderer_->OnTimeStateChanged(true);
 }
 
 void RendererImpl::OnRendererEnded(DemuxerStream::Type type) {
-  DVLOG(1) << __FUNCTION__
-           << (type == DemuxerStream::AUDIO ? " audio" : " video");
+  DVLOG(1) << __func__ << (type == DemuxerStream::AUDIO ? " audio" : " video");
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK((type == DemuxerStream::AUDIO) || (type == DemuxerStream::VIDEO));
 
   if (state_ != STATE_PLAYING)
     return;
 
   if (type == DemuxerStream::AUDIO) {
     DCHECK(!audio_ended_);
     audio_ended_ = true;
   } else {
@@ skipping 12 matching lines @@
   if (audio_renderer_ && !audio_ended_)
     return false;
 
   if (video_renderer_ && !video_ended_)
     return false;
 
   return true;
 }
 
 void RendererImpl::RunEndedCallbackIfNeeded() {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!PlaybackHasEnded())
     return;
 
   if (time_ticking_)
     PausePlayback();
 
   client_->OnEnded();
 }
 
 void RendererImpl::OnError(PipelineStatus error) {
-  DVLOG(1) << __FUNCTION__ << "(" << error << ")";
+  DVLOG(1) << __func__ << "(" << error << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   // An error has already been delivered.
   if (state_ == STATE_ERROR)
     return;
 
   const State old_state = state_;
   state_ = STATE_ERROR;
 
@@ skipping 20 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media