Restore CDM context on Resume().

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 <utility>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
       running_(false),
       did_loading_progress_(false),
       volume_(1.0f),
       playback_rate_(0.0),
       status_(PIPELINE_OK),
       state_(kCreated),
       suspend_timestamp_(kNoTimestamp()),
       renderer_ended_(false),
       text_renderer_ended_(false),
       demuxer_(NULL),
-      pending_cdm_context_(nullptr),
+      cdm_context_(nullptr),
       weak_factory_(this) {
+  weak_this_ = weak_factory_.GetWeakPtr();
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
 }
 
 PipelineImpl::~PipelineImpl() {
   DCHECK(thread_checker_.CalledOnValidThread())
       << "Pipeline must be destroyed on same thread that created it";
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(stop_cb_.is_null());
   DCHECK(seek_cb_.is_null());
 }
@@ skipping 22 matching lines @@
   renderer_ = std::move(renderer);
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = seek_cb;
   metadata_cb_ = metadata_cb;
   buffering_state_cb_ = buffering_state_cb;
   duration_change_cb_ = duration_change_cb;
   add_text_track_cb_ = add_text_track_cb;
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 
-  task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::StartTask,
-                                               weak_factory_.GetWeakPtr()));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&PipelineImpl::StartTask, weak_this_));
 }
 
 void PipelineImpl::Stop(const base::Closure& stop_cb) {
   DVLOG(2) << __FUNCTION__;
   task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&PipelineImpl::StopTask, weak_factory_.GetWeakPtr(), stop_cb));
+      FROM_HERE, base::Bind(&PipelineImpl::StopTask, weak_this_, stop_cb));
 }
 
 void PipelineImpl::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   if (!running_) {
     DLOG(ERROR) << "Media pipeline isn't running. Ignoring Seek().";
     return;
   }
 
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(&PipelineImpl::SeekTask, weak_factory_.GetWeakPtr(),
-                            time, seek_cb));
+  task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::SeekTask,
+                                               weak_this_, time, seek_cb));
 }
 
 bool PipelineImpl::IsRunning() const {
   base::AutoLock auto_lock(lock_);
   return running_;
 }
 
 double PipelineImpl::GetPlaybackRate() const {
   base::AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
 void PipelineImpl::SetPlaybackRate(double playback_rate) {
   if (playback_rate < 0.0)
     return;
 
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
   if (running_) {
-    task_runner_->PostTask(
-        FROM_HERE, base::Bind(&PipelineImpl::PlaybackRateChangedTask,
-                              weak_factory_.GetWeakPtr(), playback_rate));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&PipelineImpl::PlaybackRateChangedTask,
+                                      weak_this_, playback_rate));
   }
 }
 
 void PipelineImpl::Suspend(const PipelineStatusCB& suspend_cb) {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&PipelineImpl::SuspendTask,
-                                    weak_factory_.GetWeakPtr(), suspend_cb));
+  task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::SuspendTask,
+                                               weak_this_, suspend_cb));
 }
 
 void PipelineImpl::Resume(scoped_ptr<Renderer> renderer,
                           base::TimeDelta timestamp,
                           const PipelineStatusCB& seek_cb) {
   task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&PipelineImpl::ResumeTask, weak_factory_.GetWeakPtr(),
-                 base::Passed(&renderer), timestamp, seek_cb));
+      FROM_HERE, base::Bind(&PipelineImpl::ResumeTask, weak_this_,
+                            base::Passed(&renderer), timestamp, seek_cb));
 }
 
 float PipelineImpl::GetVolume() const {
   base::AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void PipelineImpl::SetVolume(float volume) {
   if (volume < 0.0f || volume > 1.0f)
     return;
 
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
-    task_runner_->PostTask(FROM_HERE,
-                           base::Bind(&PipelineImpl::VolumeChangedTask,
-                                      weak_factory_.GetWeakPtr(), volume));
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&PipelineImpl::VolumeChangedTask, weak_this_, volume));
   }
 }
 
 TimeDelta PipelineImpl::GetMediaTime() const {
   base::AutoLock auto_lock(lock_);
   if (suspend_timestamp_ != kNoTimestamp())
     return suspend_timestamp_;
   return renderer_ ? std::min(renderer_->GetMediaTime(), duration_)
                    : TimeDelta();
 }
@@ skipping 15 matching lines @@
   return ret;
 }
 
 PipelineStatistics PipelineImpl::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
 }
 
 void PipelineImpl::SetCdm(CdmContext* cdm_context,
                           const CdmAttachedCB& cdm_attached_cb) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::SetCdmTask,
-                                               weak_factory_.GetWeakPtr(),
-                                               cdm_context, cdm_attached_cb));
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&PipelineImpl::SetCdmTask, weak_this_, cdm_context,
+                            cdm_attached_cb));
 }
 
 void PipelineImpl::SetErrorForTesting(PipelineStatus status) {
   OnError(status);
 }
 
 bool PipelineImpl::HasWeakPtrsForTesting() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return weak_factory_.HasWeakPtrs();
 }
@@ skipping 57 matching lines @@
     case kPlaying:
     case kStopping:
     case kStopped:
       break;
   }
   NOTREACHED() << "State has no transition: " << state_;
   return state_;
 }
 
 void PipelineImpl::OnDemuxerError(PipelineStatus error) {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&PipelineImpl::ErrorChangedTask,
-                                    weak_factory_.GetWeakPtr(), error));
+  task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::ErrorChangedTask,
+                                               weak_this_, error));
 }
 
 void PipelineImpl::AddTextStream(DemuxerStream* text_stream,
                                  const TextTrackConfig& config) {
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(&PipelineImpl::AddTextStreamTask,
-                            weak_factory_.GetWeakPtr(), text_stream, config));
+      FROM_HERE, base::Bind(&PipelineImpl::AddTextStreamTask, weak_this_,
+                            text_stream, config));
 }
 
 void PipelineImpl::RemoveTextStream(DemuxerStream* text_stream) {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&PipelineImpl::RemoveTextStreamTask,
-                                    weak_factory_.GetWeakPtr(), text_stream));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&PipelineImpl::RemoveTextStreamTask, weak_this_, text_stream));
 }
 
 void PipelineImpl::OnError(PipelineStatus error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&PipelineImpl::ErrorChangedTask,
-                                    weak_factory_.GetWeakPtr(), error));
+  task_runner_->PostTask(FROM_HERE, base::Bind(&PipelineImpl::ErrorChangedTask,
+                                               weak_this_, error));
 }
 
 void PipelineImpl::SetDuration(TimeDelta duration) {
   DCHECK(IsRunning());
   media_log_->AddEvent(media_log_->CreateTimeEvent(MediaLogEvent::DURATION_SET,
                                                    "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
   duration_ = duration;
@@ skipping 17 matching lines @@
     return;
   }
 
   // Guard against accidentally clearing |pending_callbacks_| for states that
   // use it as well as states that should not be using it.
   DCHECK_EQ(pending_callbacks_.get() != NULL,
             state_ == kSeeking || state_ == kSuspending || state_ == kResuming);
 
   pending_callbacks_.reset();
 
-  PipelineStatusCB done_cb = base::Bind(&PipelineImpl::StateTransitionTask,
-                                        weak_factory_.GetWeakPtr());
+  PipelineStatusCB done_cb =
+      base::Bind(&PipelineImpl::StateTransitionTask, weak_this_);
 
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
     case kInitRenderer:
       // When the state_ transfers to kInitRenderer, it means the demuxer has
       // finished parsing the init info. It should call ReportMetadata in case
@@ skipping 161 matching lines @@
 }
 
 void PipelineImpl::StartTask() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
   text_renderer_ = CreateTextRenderer();
   if (text_renderer_) {
-    text_renderer_->Initialize(base::Bind(&PipelineImpl::OnTextRendererEnded,
-                                          weak_factory_.GetWeakPtr()));
-  }
-
-  // Set CDM early to avoid unnecessary delay in Renderer::Initialize().
-  if (pending_cdm_context_) {
-    renderer_->SetCdm(pending_cdm_context_, base::Bind(&IgnoreCdmAttached));
-    pending_cdm_context_ = nullptr;
+    text_renderer_->Initialize(
+        base::Bind(&PipelineImpl::OnTextRendererEnded, weak_this_));
   }
 
   StateTransitionTask(PIPELINE_OK);
 }
 
 void PipelineImpl::StopTask(const base::Closure& stop_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stop_cb_.is_null());
 
   if (state_ == kStopped) {
@@ skipping 19 matching lines @@
       state_ == kSuspended || state_ == kResuming) {
     PipelineStatistics stats = GetStatistics();
     if (stats.video_frames_decoded > 0) {
       UMA_HISTOGRAM_COUNTS("Media.DroppedFrameCount",
                            stats.video_frames_dropped);
     }
   }
 
   SetState(kStopping);
   pending_callbacks_.reset();
-  DoStop(
-      base::Bind(&PipelineImpl::OnStopCompleted, weak_factory_.GetWeakPtr()));
+  DoStop(base::Bind(&PipelineImpl::OnStopCompleted, weak_this_));
 }
 
 void PipelineImpl::ErrorChangedTask(PipelineStatus error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   // Don't report pipeline error events to the media log here. The embedder will
   // log this when |error_cb_| is called. If the pipeline is already stopped or
   // stopping we also don't want to log any event. In case we are suspending or
   // suspended, the error may be recoverable, so don't propagate it now, instead
   // let the subsequent seek during resume propagate it if it's unrecoverable.
 
   if (state_ == kStopping || state_ == kStopped || state_ == kSuspending ||
       state_ == kSuspended) {
     return;
   }
 
   SetState(kStopping);
   pending_callbacks_.reset();
   status_ = error;
 
-  DoStop(
-      base::Bind(&PipelineImpl::OnStopCompleted, weak_factory_.GetWeakPtr()));
+  DoStop(base::Bind(&PipelineImpl::OnStopCompleted, weak_this_));
 }
 
 void PipelineImpl::PlaybackRateChangedTask(double playback_rate) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
   if (state_ != kPlaying)
     return;
 
   renderer_->SetPlaybackRate(playback_rate);
@@ skipping 25 matching lines @@
 
   const base::TimeDelta seek_timestamp =
       std::max(time, demuxer_->GetStartTime());
 
   SetState(kSeeking);
   seek_cb_ = seek_cb;
   renderer_ended_ = false;
   text_renderer_ended_ = false;
   start_timestamp_ = seek_timestamp;
 
-  DoSeek(seek_timestamp, base::Bind(&PipelineImpl::StateTransitionTask,
-                                    weak_factory_.GetWeakPtr()));
+  DoSeek(seek_timestamp,
+         base::Bind(&PipelineImpl::StateTransitionTask, weak_this_));
 }
 
 void PipelineImpl::SuspendTask(const PipelineStatusCB& suspend_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Suppress suspending if we're not playing.
   if (state_ != kPlaying) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive suspend in unexpected state: " << state_;
     suspend_cb.Run(PIPELINE_ERROR_INVALID_STATE);
@@ skipping 24 matching lines @@
                         base::Unretained(text_renderer_.get())));
   }
 
   fns.Push(base::Bind(&Renderer::Flush, base::Unretained(renderer_.get())));
 
   if (text_renderer_) {
     fns.Push(base::Bind(&TextRenderer::Flush,
                         base::Unretained(text_renderer_.get())));
   }
 
-  pending_callbacks_ =
-      SerialRunner::Run(fns, base::Bind(&PipelineImpl::StateTransitionTask,
-                                        weak_factory_.GetWeakPtr()));
+  pending_callbacks_ = SerialRunner::Run(
+      fns, base::Bind(&PipelineImpl::StateTransitionTask, weak_this_));
 }
 
 void PipelineImpl::ResumeTask(scoped_ptr<Renderer> renderer,
                               base::TimeDelta timestamp,
                               const PipelineStatusCB& seek_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Suppress resuming if we're not suspended.
   if (state_ != kSuspended) {
     DCHECK(state_ == kStopping || state_ == kStopped)
@@ skipping 12 matching lines @@
   seek_cb_ = seek_cb;
   renderer_ended_ = false;
   text_renderer_ended_ = false;
   start_timestamp_ = std::max(timestamp, demuxer_->GetStartTime());
 
   // Queue the asynchronous actions required to start playback. Unlike DoSeek(),
   // we need to initialize the renderer ourselves (we don't want to enter state
   // kInitDemuxer, and even if we did the current code would seek to the start
   // instead of |timestamp|).
   SerialRunner::Queue fns;
-  base::WeakPtr<PipelineImpl> weak_this = weak_factory_.GetWeakPtr();
 
   fns.Push(
       base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), start_timestamp_));
 
-  fns.Push(base::Bind(&PipelineImpl::InitializeRenderer, weak_this));
+  fns.Push(base::Bind(&PipelineImpl::InitializeRenderer, weak_this_));
 
   pending_callbacks_ = SerialRunner::Run(
-      fns, base::Bind(&PipelineImpl::StateTransitionTask, weak_this));
+      fns, base::Bind(&PipelineImpl::StateTransitionTask, weak_this_));
 }
 
 void PipelineImpl::SetCdmTask(CdmContext* cdm_context,
                               const CdmAttachedCB& cdm_attached_cb) {
   base::AutoLock auto_lock(lock_);
   if (!renderer_) {
-    pending_cdm_context_ = cdm_context;
+    cdm_context_ = cdm_context;
     cdm_attached_cb.Run(true);
     return;
   }
 
-  renderer_->SetCdm(cdm_context, cdm_attached_cb);
+  renderer_->SetCdm(cdm_context,
+                    base::Bind(&PipelineImpl::OnCdmAttached, weak_this_,
+                               cdm_attached_cb, cdm_context));
+}
+
+void PipelineImpl::OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
+                                 CdmContext* cdm_context,
+                                 bool success) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (success)
+    cdm_context_ = cdm_context;
+  cdm_attached_cb.Run(success);
 }
 
 void PipelineImpl::OnRendererEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!renderer_ended_);
@@ skipping 29 matching lines @@
 }
 
 scoped_ptr<TextRenderer> PipelineImpl::CreateTextRenderer() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (!cmd_line->HasSwitch(switches::kEnableInbandTextTracks))
     return scoped_ptr<media::TextRenderer>();
 
   return scoped_ptr<media::TextRenderer>(new media::TextRenderer(
-      task_runner_,
-      base::Bind(&PipelineImpl::OnAddTextTrack, weak_factory_.GetWeakPtr())));
+      task_runner_, base::Bind(&PipelineImpl::OnAddTextTrack, weak_this_)));
 }
 
 void PipelineImpl::AddTextStreamTask(DemuxerStream* text_stream,
                                      const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   // TODO(matthewjheaney): fix up text_ended_ when text stream
   // is added (http://crbug.com/321446).
   if (text_renderer_)
     text_renderer_->AddTextStream(text_stream, config);
 }
@@ skipping 21 matching lines @@
   if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
       !demuxer_->GetStream(DemuxerStream::VIDEO)) {
     {
       base::AutoLock auto_lock(lock_);
       renderer_.reset();
     }
     OnError(PIPELINE_ERROR_COULD_NOT_RENDER);
     return;
   }
 
-  base::WeakPtr<PipelineImpl> weak_this = weak_factory_.GetWeakPtr();
+  if (cdm_context_)
+    renderer_->SetCdm(cdm_context_, base::Bind(&IgnoreCdmAttached));
+
   renderer_->Initialize(
       demuxer_, done_cb,
-      base::Bind(&PipelineImpl::OnUpdateStatistics, weak_this),
-      base::Bind(&PipelineImpl::BufferingStateChanged, weak_this),
-      base::Bind(&PipelineImpl::OnRendererEnded, weak_this),
-      base::Bind(&PipelineImpl::OnError, weak_this),
+      base::Bind(&PipelineImpl::OnUpdateStatistics, weak_this_),
+      base::Bind(&PipelineImpl::BufferingStateChanged, weak_this_),
+      base::Bind(&PipelineImpl::OnRendererEnded, weak_this_),
+      base::Bind(&PipelineImpl::OnError, weak_this_),
       waiting_for_decryption_key_cb_);
 }
 
 void PipelineImpl::ReportMetadata() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   PipelineMetadata metadata;
   metadata.timeline_offset = demuxer_->GetTimelineOffset();
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   if (stream) {
     metadata.has_video = true;
     metadata.natural_size = stream->video_decoder_config().natural_size();
     metadata.video_rotation = stream->video_rotation();
   }
   if (demuxer_->GetStream(DemuxerStream::AUDIO)) {
     metadata.has_audio = true;
   }
   metadata_cb_.Run(metadata);
 }
 
 void PipelineImpl::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media