media/renderers/renderer_impl.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/renderers/renderer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/callback_helpers.h"
  10 #include "base/command_line.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/location.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "media/base/audio_renderer.h"
  16 #include "media/base/bind_to_current_loop.h"
  17 #include "media/base/demuxer_stream_provider.h"
  18 #include "media/base/media_switches.h"
  19 #include "media/base/time_source.h"
  20 #include "media/base/video_renderer.h"
  21 #include "media/base/wall_clock_time_source.h"
  22
  23 namespace media {
  24
  25 // See |video_underflow_threshold_|.
  26 static const int kDefaultVideoUnderflowThresholdMs = 3000;
  27
  28 RendererImpl::RendererImpl(
  29     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  30     scoped_ptr<AudioRenderer> audio_renderer,
  31     scoped_ptr<VideoRenderer> video_renderer)
  32     : state_(STATE_UNINITIALIZED),
  33       task_runner_(task_runner),
  34       audio_renderer_(audio_renderer.Pass()),
  35       video_renderer_(video_renderer.Pass()),
  36       time_source_(NULL),
  37       time_ticking_(false),
  38       playback_rate_(0),
  39       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
  40       video_buffering_state_(BUFFERING_HAVE_NOTHING),
  41       audio_ended_(false),
  42       video_ended_(false),
  43       cdm_context_(nullptr),
  44       underflow_disabled_for_testing_(false),
  45       clockless_video_playback_enabled_for_testing_(false),
  46       video_underflow_threshold_(
  47           base::TimeDelta::FromMilliseconds(kDefaultVideoUnderflowThresholdMs)),
  48       weak_factory_(this) {
  49   weak_this_ = weak_factory_.GetWeakPtr();
  50   DVLOG(1) << __FUNCTION__;
  51
  52   // TODO(dalecurtis): Remove once experiments for http://crbug.com/470940 are
  53   // complete.
  54   int threshold_ms = 0;
  55   std::string threshold_ms_str(
  56       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
  57           switches::kVideoUnderflowThresholdMs));
  58   if (base::StringToInt(threshold_ms_str, &threshold_ms) && threshold_ms > 0) {
  59     video_underflow_threshold_ =
  60         base::TimeDelta::FromMilliseconds(threshold_ms);
  61   }
  62 }
  63
  64 RendererImpl::~RendererImpl() {
  65   DVLOG(1) << __FUNCTION__;
  66   DCHECK(task_runner_->BelongsToCurrentThread());
  67
  68   // Tear down in opposite order of construction as |video_renderer_| can still
  69   // need |time_source_| (which can be |audio_renderer_|) to be alive.
  70   video_renderer_.reset();
  71   audio_renderer_.reset();
  72
  73   if (!init_cb_.is_null())
  74     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
  75   else if (!flush_cb_.is_null())
  76     base::ResetAndReturn(&flush_cb_).Run();
  77 }
  78
  79 void RendererImpl::Initialize(
  80     DemuxerStreamProvider* demuxer_stream_provider,
  81     const PipelineStatusCB& init_cb,
  82     const StatisticsCB& statistics_cb,
  83     const BufferingStateCB& buffering_state_cb,
  84     const PaintCB& paint_cb,
  85     const base::Closure& ended_cb,
  86     const PipelineStatusCB& error_cb,
  87     const base::Closure& waiting_for_decryption_key_cb) {
  88   DVLOG(1) << __FUNCTION__;
  89   DCHECK(task_runner_->BelongsToCurrentThread());
  90   DCHECK_EQ(state_, STATE_UNINITIALIZED);
  91   DCHECK(!init_cb.is_null());
  92   DCHECK(!statistics_cb.is_null());
  93   DCHECK(!buffering_state_cb.is_null());
  94   DCHECK(!paint_cb.is_null());
  95   DCHECK(!ended_cb.is_null());
  96   DCHECK(!error_cb.is_null());
  97   DCHECK(demuxer_stream_provider->GetStream(DemuxerStream::AUDIO) ||
  98          demuxer_stream_provider->GetStream(DemuxerStream::VIDEO));
  99
 100   demuxer_stream_provider_ = demuxer_stream_provider;
 101   statistics_cb_ = statistics_cb;
 102   buffering_state_cb_ = buffering_state_cb;
 103   paint_cb_ = paint_cb;
 104   ended_cb_ = ended_cb;
 105   error_cb_ = error_cb;
 106   init_cb_ = init_cb;
 107   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 108
 109   state_ = STATE_INITIALIZING;
 110   InitializeAudioRenderer();
 111 }
 112
 113 void RendererImpl::SetCdm(CdmContext* cdm_context,
 114                           const CdmAttachedCB& cdm_attached_cb) {
 115   DVLOG(1) << __FUNCTION__;
 116   DCHECK(task_runner_->BelongsToCurrentThread());
 117   DCHECK(cdm_context);
 118
 119   if (cdm_context_) {
 120     DVLOG(1) << "Switching CDM not supported.";
 121     cdm_attached_cb.Run(false);
 122     return;
 123   }
 124
 125   cdm_context_ = cdm_context;
 126
 127   if (decryptor_ready_cb_.is_null()) {
 128     cdm_attached_cb.Run(true);
 129     return;
 130   }
 131
 132   base::ResetAndReturn(&decryptor_ready_cb_)
 133       .Run(cdm_context->GetDecryptor(), cdm_attached_cb);
 134 }
 135
 136 void RendererImpl::Flush(const base::Closure& flush_cb) {
 137   DVLOG(1) << __FUNCTION__;
 138   DCHECK(task_runner_->BelongsToCurrentThread());
 139   DCHECK(flush_cb_.is_null());
 140
 141   if (state_ != STATE_PLAYING) {
 142     DCHECK_EQ(state_, STATE_ERROR);
 143     return;
 144   }
 145
 146   flush_cb_ = flush_cb;
 147   state_ = STATE_FLUSHING;
 148
 149   if (time_ticking_)
 150     PausePlayback();
 151
 152   FlushAudioRenderer();
 153 }
 154
 155 void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
 156   DVLOG(1) << __FUNCTION__;
 157   DCHECK(task_runner_->BelongsToCurrentThread());
 158
 159   if (state_ != STATE_PLAYING) {
 160     DCHECK_EQ(state_, STATE_ERROR);
 161     return;
 162   }
 163
 164   time_source_->SetMediaTime(time);
 165
 166   if (audio_renderer_)
 167     audio_renderer_->StartPlaying();
 168   if (video_renderer_)
 169     video_renderer_->StartPlayingFrom(time);
 170 }
 171
 172 void RendererImpl::SetPlaybackRate(float playback_rate) {
 173   DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
 174   DCHECK(task_runner_->BelongsToCurrentThread());
 175
 176   // Playback rate changes are only carried out while playing.
 177   if (state_ != STATE_PLAYING)
 178     return;
 179
 180   time_source_->SetPlaybackRate(playback_rate);
 181
 182   const float old_rate = playback_rate_;
 183   playback_rate_ = playback_rate;
 184   if (!time_ticking_ || !video_renderer_)
 185     return;
 186
 187   if (old_rate == 0 && playback_rate > 0)
 188     video_renderer_->OnTimeStateChanged(true);
 189   else if (old_rate > 0 && playback_rate == 0)
 190     video_renderer_->OnTimeStateChanged(false);
 191 }
 192
 193 void RendererImpl::SetVolume(float volume) {
 194   DVLOG(1) << __FUNCTION__;
 195   DCHECK(task_runner_->BelongsToCurrentThread());
 196
 197   if (audio_renderer_)
 198     audio_renderer_->SetVolume(volume);
 199 }
 200
 201 base::TimeDelta RendererImpl::GetMediaTime() {
 202   // No BelongsToCurrentThread() checking because this can be called from other
 203   // threads.
 204   return time_source_->CurrentMediaTime();
 205 }
 206
 207 bool RendererImpl::HasAudio() {
 208   DCHECK(task_runner_->BelongsToCurrentThread());
 209   return audio_renderer_ != NULL;
 210 }
 211
 212 bool RendererImpl::HasVideo() {
 213   DCHECK(task_runner_->BelongsToCurrentThread());
 214   return video_renderer_ != NULL;
 215 }
 216
 217 void RendererImpl::DisableUnderflowForTesting() {
 218   DVLOG(1) << __FUNCTION__;
 219   DCHECK(task_runner_->BelongsToCurrentThread());
 220   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 221
 222   underflow_disabled_for_testing_ = true;
 223 }
 224
 225 void RendererImpl::EnableClocklessVideoPlaybackForTesting() {
 226   DVLOG(1) << __FUNCTION__;
 227   DCHECK(task_runner_->BelongsToCurrentThread());
 228   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 229   DCHECK(underflow_disabled_for_testing_)
 230       << "Underflow must be disabled for clockless video playback";
 231
 232   clockless_video_playback_enabled_for_testing_ = true;
 233 }
 234
 235 base::TimeTicks RendererImpl::GetWallClockTime(base::TimeDelta time) {
 236   // No BelongsToCurrentThread() checking because this can be called from other
 237   // threads.
 238   //
 239   // TODO(scherkus): Currently called from VideoRendererImpl's internal thread,
 240   // which should go away at some point http://crbug.com/110814
 241   if (clockless_video_playback_enabled_for_testing_)
 242     return base::TimeTicks::Now();
 243
 244   return time_source_->GetWallClockTime(time);
 245 }
 246
 247 void RendererImpl::SetDecryptorReadyCallback(
 248     const DecryptorReadyCB& decryptor_ready_cb) {
 249   // Cancels the previous decryptor request.
 250   if (decryptor_ready_cb.is_null()) {
 251     if (!decryptor_ready_cb_.is_null()) {
 252       base::ResetAndReturn(&decryptor_ready_cb_)
 253           .Run(nullptr, base::Bind(IgnoreCdmAttached));
 254     }
 255     return;
 256   }
 257
 258   // We initialize audio and video decoders in sequence.
 259   DCHECK(decryptor_ready_cb_.is_null());
 260
 261   if (cdm_context_) {
 262     decryptor_ready_cb.Run(cdm_context_->GetDecryptor(),
 263                            base::Bind(IgnoreCdmAttached));
 264     return;
 265   }
 266
 267   decryptor_ready_cb_ = decryptor_ready_cb;
 268 }
 269
 270 void RendererImpl::InitializeAudioRenderer() {
 271   DVLOG(1) << __FUNCTION__;
 272   DCHECK(task_runner_->BelongsToCurrentThread());
 273   DCHECK_EQ(state_, STATE_INITIALIZING);
 274   DCHECK(!init_cb_.is_null());
 275
 276   PipelineStatusCB done_cb =
 277       base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 278
 279   if (!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO)) {
 280     audio_renderer_.reset();
 281     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 282     return;
 283   }
 284
 285   // Note: After the initialization of a renderer, error events from it may
 286   // happen at any time and all future calls must guard against STATE_ERROR.
 287   audio_renderer_->Initialize(
 288       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO), done_cb,
 289       base::Bind(&RendererImpl::SetDecryptorReadyCallback, weak_this_),
 290       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
 291       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
 292                  &audio_buffering_state_),
 293       base::Bind(&RendererImpl::OnAudioRendererEnded, weak_this_),
 294       base::Bind(&RendererImpl::OnError, weak_this_),
 295       waiting_for_decryption_key_cb_);
 296 }
 297
 298 void RendererImpl::OnAudioRendererInitializeDone(PipelineStatus status) {
 299   DVLOG(1) << __FUNCTION__ << ": " << status;
 300   DCHECK(task_runner_->BelongsToCurrentThread());
 301
 302   // OnError() may be fired at any time by the renderers, even if they thought
 303   // they initialized successfully (due to delayed output device setup).
 304   if (state_ != STATE_INITIALIZING) {
 305     DCHECK(init_cb_.is_null());
 306     audio_renderer_.reset();
 307     return;
 308   }
 309
 310   if (status != PIPELINE_OK) {
 311     base::ResetAndReturn(&init_cb_).Run(status);
 312     return;
 313   }
 314
 315   DCHECK(!init_cb_.is_null());
 316   InitializeVideoRenderer();
 317 }
 318
 319 void RendererImpl::InitializeVideoRenderer() {
 320   DVLOG(1) << __FUNCTION__;
 321   DCHECK(task_runner_->BelongsToCurrentThread());
 322   DCHECK_EQ(state_, STATE_INITIALIZING);
 323   DCHECK(!init_cb_.is_null());
 324
 325   PipelineStatusCB done_cb =
 326       base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 327
 328   if (!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO)) {
 329     video_renderer_.reset();
 330     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 331     return;
 332   }
 333
 334   video_renderer_->Initialize(
 335       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO), done_cb,
 336       base::Bind(&RendererImpl::SetDecryptorReadyCallback, weak_this_),
 337       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
 338       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
 339                  &video_buffering_state_),
 340       base::ResetAndReturn(&paint_cb_),
 341       base::Bind(&RendererImpl::OnVideoRendererEnded, weak_this_),
 342       base::Bind(&RendererImpl::OnError, weak_this_),
 343       base::Bind(&RendererImpl::GetWallClockTime, base::Unretained(this)),
 344       waiting_for_decryption_key_cb_);
 345 }
 346
 347 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
 348   DVLOG(1) << __FUNCTION__ << ": " << status;
 349   DCHECK(task_runner_->BelongsToCurrentThread());
 350
 351   // OnError() may be fired at any time by the renderers, even if they thought
 352   // they initialized successfully (due to delayed output device setup).
 353   if (state_ != STATE_INITIALIZING) {
 354     DCHECK(init_cb_.is_null());
 355     audio_renderer_.reset();
 356     video_renderer_.reset();
 357     return;
 358   }
 359
 360   DCHECK(!init_cb_.is_null());
 361
 362   if (status != PIPELINE_OK) {
 363     base::ResetAndReturn(&init_cb_).Run(status);
 364     return;
 365   }
 366
 367   if (audio_renderer_) {
 368     time_source_ = audio_renderer_->GetTimeSource();
 369   } else if (!time_source_) {
 370     wall_clock_time_source_.reset(new WallClockTimeSource());
 371     time_source_ = wall_clock_time_source_.get();
 372   }
 373
 374   state_ = STATE_PLAYING;
 375   DCHECK(time_source_);
 376   DCHECK(audio_renderer_ || video_renderer_);
 377   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 378 }
 379
 380 void RendererImpl::FlushAudioRenderer() {
 381   DVLOG(1) << __FUNCTION__;
 382   DCHECK(task_runner_->BelongsToCurrentThread());
 383   DCHECK_EQ(state_, STATE_FLUSHING);
 384   DCHECK(!flush_cb_.is_null());
 385
 386   if (!audio_renderer_) {
 387     OnAudioRendererFlushDone();
 388     return;
 389   }
 390
 391   audio_renderer_->Flush(
 392       base::Bind(&RendererImpl::OnAudioRendererFlushDone, weak_this_));
 393 }
 394
 395 void RendererImpl::OnAudioRendererFlushDone() {
 396   DVLOG(1) << __FUNCTION__;
 397   DCHECK(task_runner_->BelongsToCurrentThread());
 398
 399   if (state_ == STATE_ERROR) {
 400     DCHECK(flush_cb_.is_null());
 401     return;
 402   }
 403
 404   DCHECK_EQ(state_, STATE_FLUSHING);
 405   DCHECK(!flush_cb_.is_null());
 406
 407   DCHECK_EQ(audio_buffering_state_, BUFFERING_HAVE_NOTHING);
 408   audio_ended_ = false;
 409   FlushVideoRenderer();
 410 }
 411
 412 void RendererImpl::FlushVideoRenderer() {
 413   DVLOG(1) << __FUNCTION__;
 414   DCHECK(task_runner_->BelongsToCurrentThread());
 415   DCHECK_EQ(state_, STATE_FLUSHING);
 416   DCHECK(!flush_cb_.is_null());
 417
 418   if (!video_renderer_) {
 419     OnVideoRendererFlushDone();
 420     return;
 421   }
 422
 423   video_renderer_->Flush(
 424       base::Bind(&RendererImpl::OnVideoRendererFlushDone, weak_this_));
 425 }
 426
 427 void RendererImpl::OnVideoRendererFlushDone() {
 428   DVLOG(1) << __FUNCTION__;
 429   DCHECK(task_runner_->BelongsToCurrentThread());
 430
 431   if (state_ == STATE_ERROR) {
 432     DCHECK(flush_cb_.is_null());
 433     return;
 434   }
 435
 436   DCHECK_EQ(state_, STATE_FLUSHING);
 437   DCHECK(!flush_cb_.is_null());
 438
 439   DCHECK_EQ(video_buffering_state_, BUFFERING_HAVE_NOTHING);
 440   video_ended_ = false;
 441   state_ = STATE_PLAYING;
 442   base::ResetAndReturn(&flush_cb_).Run();
 443 }
 444
 445 void RendererImpl::OnUpdateStatistics(const PipelineStatistics& stats) {
 446   DCHECK(task_runner_->BelongsToCurrentThread());
 447   statistics_cb_.Run(stats);
 448 }
 449
 450 void RendererImpl::OnBufferingStateChanged(BufferingState* buffering_state,
 451                                            BufferingState new_buffering_state) {
 452   const bool is_audio = buffering_state == &audio_buffering_state_;
 453   DVLOG(1) << __FUNCTION__ << "(" << *buffering_state << ", "
 454            << new_buffering_state << ") " << (is_audio ? "audio" : "video");
 455   DCHECK(task_runner_->BelongsToCurrentThread());
 456
 457   bool was_waiting_for_enough_data = WaitingForEnoughData();
 458
 459   // When audio is present, defer underflow callbacks for some time to avoid
 460   // unnecessary glitches in audio; see http://crbug.com/144683#c53.
 461   if (audio_renderer_ && !is_audio && state_ == STATE_PLAYING) {
 462     if (video_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
 463         new_buffering_state == BUFFERING_HAVE_NOTHING &&
 464         deferred_underflow_cb_.IsCancelled()) {
 465       deferred_underflow_cb_.Reset(base::Bind(
 466           &RendererImpl::OnBufferingStateChanged, weak_factory_.GetWeakPtr(),
 467           buffering_state, new_buffering_state));
 468       task_runner_->PostDelayedTask(FROM_HERE,
 469                                     deferred_underflow_cb_.callback(),
 470                                     video_underflow_threshold_);
 471       return;
 472     }
 473
 474     deferred_underflow_cb_.Cancel();
 475   } else if (!deferred_underflow_cb_.IsCancelled() && is_audio &&
 476              new_buffering_state == BUFFERING_HAVE_NOTHING) {
 477     // If audio underflows while we have a deferred video underflow in progress
 478     // we want to mark video as underflowed immediately and cancel the deferral.
 479     deferred_underflow_cb_.Cancel();
 480     video_buffering_state_ = BUFFERING_HAVE_NOTHING;
 481   }
 482
 483   *buffering_state = new_buffering_state;
 484
 485   // Disable underflow by ignoring updates that renderers have ran out of data.
 486   if (state_ == STATE_PLAYING && underflow_disabled_for_testing_ &&
 487       time_ticking_) {
 488     DVLOG(1) << "Update ignored because underflow is disabled for testing.";
 489     return;
 490   }
 491
 492   // Renderer underflowed.
 493   if (!was_waiting_for_enough_data && WaitingForEnoughData()) {
 494     PausePlayback();
 495
 496     // TODO(scherkus): Fire BUFFERING_HAVE_NOTHING callback to alert clients of
 497     // underflow state http://crbug.com/144683
 498     return;
 499   }
 500
 501   // Renderer prerolled.
 502   if (was_waiting_for_enough_data && !WaitingForEnoughData()) {
 503     StartPlayback();
 504     buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
 505     return;
 506   }
 507 }
 508
 509 bool RendererImpl::WaitingForEnoughData() const {
 510   DCHECK(task_runner_->BelongsToCurrentThread());
 511   if (state_ != STATE_PLAYING)
 512     return false;
 513   if (audio_renderer_ && audio_buffering_state_ != BUFFERING_HAVE_ENOUGH)
 514     return true;
 515   if (video_renderer_ && video_buffering_state_ != BUFFERING_HAVE_ENOUGH)
 516     return true;
 517   return false;
 518 }
 519
 520 void RendererImpl::PausePlayback() {
 521   DVLOG(1) << __FUNCTION__;
 522   DCHECK(task_runner_->BelongsToCurrentThread());
 523   DCHECK(time_ticking_);
 524   switch (state_) {
 525     case STATE_PLAYING:
 526       DCHECK(PlaybackHasEnded() || WaitingForEnoughData())
 527           << "Playback should only pause due to ending or underflowing";
 528       break;
 529
 530     case STATE_FLUSHING:
 531       // It's OK to pause playback when flushing.
 532       break;
 533
 534     case STATE_UNINITIALIZED:
 535     case STATE_INITIALIZING:
 536       NOTREACHED() << "Invalid state: " << state_;
 537       break;
 538
 539     case STATE_ERROR:
 540       // An error state may occur at any time.
 541       break;
 542   }
 543
 544   time_ticking_ = false;
 545   time_source_->StopTicking();
 546   if (playback_rate_ > 0 && video_renderer_)
 547     video_renderer_->OnTimeStateChanged(false);
 548 }
 549
 550 void RendererImpl::StartPlayback() {
 551   DVLOG(1) << __FUNCTION__;
 552   DCHECK(task_runner_->BelongsToCurrentThread());
 553   DCHECK_EQ(state_, STATE_PLAYING);
 554   DCHECK(!time_ticking_);
 555   DCHECK(!WaitingForEnoughData());
 556
 557   time_ticking_ = true;
 558   time_source_->StartTicking();
 559   if (playback_rate_ > 0 && video_renderer_)
 560     video_renderer_->OnTimeStateChanged(true);
 561 }
 562
 563 void RendererImpl::OnAudioRendererEnded() {
 564   DVLOG(1) << __FUNCTION__;
 565   DCHECK(task_runner_->BelongsToCurrentThread());
 566
 567   if (state_ != STATE_PLAYING)
 568     return;
 569
 570   DCHECK(!audio_ended_);
 571   audio_ended_ = true;
 572
 573   RunEndedCallbackIfNeeded();
 574 }
 575
 576 void RendererImpl::OnVideoRendererEnded() {
 577   DVLOG(1) << __FUNCTION__;
 578   DCHECK(task_runner_->BelongsToCurrentThread());
 579
 580   if (state_ != STATE_PLAYING)
 581     return;
 582
 583   DCHECK(!video_ended_);
 584   video_ended_ = true;
 585
 586   RunEndedCallbackIfNeeded();
 587 }
 588
 589 bool RendererImpl::PlaybackHasEnded() const {
 590   DVLOG(1) << __FUNCTION__;
 591   DCHECK(task_runner_->BelongsToCurrentThread());
 592
 593   if (audio_renderer_ && !audio_ended_)
 594     return false;
 595
 596   if (video_renderer_ && !video_ended_)
 597     return false;
 598
 599   return true;
 600 }
 601
 602 void RendererImpl::RunEndedCallbackIfNeeded() {
 603   DVLOG(1) << __FUNCTION__;
 604   DCHECK(task_runner_->BelongsToCurrentThread());
 605
 606   if (!PlaybackHasEnded())
 607     return;
 608
 609   if (time_ticking_)
 610     PausePlayback();
 611
 612   ended_cb_.Run();
 613 }
 614
 615 void RendererImpl::OnError(PipelineStatus error) {
 616   DVLOG(1) << __FUNCTION__ << "(" << error << ")";
 617   DCHECK(task_runner_->BelongsToCurrentThread());
 618   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 619
 620   // An error has already been delivered.
 621   if (state_ == STATE_ERROR)
 622     return;
 623
 624   const State old_state = state_;
 625   state_ = STATE_ERROR;
 626
 627   if (old_state == STATE_INITIALIZING) {
 628     base::ResetAndReturn(&init_cb_).Run(error);
 629     return;
 630   }
 631
 632   // After OnError() returns, the pipeline may destroy |this|.
 633   base::ResetAndReturn(&error_cb_).Run(error);
 634
 635   if (!flush_cb_.is_null())
 636     base::ResetAndReturn(&flush_cb_).Run();
 637 }
 638
 639 }  // namespace media