Encrypted Media: Support Audio Decrypt-Only.

media/base/pipeline.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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 84 matching lines @@
       << "Pipeline must be destroyed on same thread that created it";
 #endif
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(stop_cb_.is_null());
   DCHECK(seek_cb_.is_null());
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
-void Pipeline::Start(scoped_ptr<FilterCollection> collection,
-                     const PipelineStatusCB& ended_cb,
-                     const PipelineStatusCB& error_cb,
-                     const PipelineStatusCB& seek_cb,
-                     const BufferingStateCB& buffering_state_cb) {
+void Pipeline::Start(
+    scoped_ptr<FilterCollection> collection,
+    const PipelineStatusCB& ended_cb,
+    const PipelineStatusCB& error_cb,
+    const PipelineStatusCB& seek_cb,
+    const BufferingStateCB& buffering_state_cb,
+    const RequestDecryptorNotificationCB& request_decryptor_notification_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
   DCHECK(!buffering_state_cb.is_null());
 
   running_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StartTask, this, base::Passed(&collection),
-      ended_cb, error_cb, seek_cb, buffering_state_cb));
+      ended_cb, error_cb, seek_cb, buffering_state_cb,
+      request_decryptor_notification_cb));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
   base::AutoLock auto_lock(lock_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StopTask, this, stop_cb));
 }
 
 void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
@@ skipping 558 matching lines @@
 
 // Called from any thread.
 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
-void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
-                         const PipelineStatusCB& ended_cb,
-                         const PipelineStatusCB& error_cb,
-                         const PipelineStatusCB& seek_cb,
-                         const BufferingStateCB& buffering_state_cb) {
+void Pipeline::StartTask(
+    scoped_ptr<FilterCollection> filter_collection,
+    const PipelineStatusCB& ended_cb,
+    const PipelineStatusCB& error_cb,
+    const PipelineStatusCB& seek_cb,
+    const BufferingStateCB& buffering_state_cb,
+    const RequestDecryptorNotificationCB& request_decryptor_notification_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
   filter_collection_ = filter_collection.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = seek_cb;
   buffering_state_cb_ = buffering_state_cb;
+  request_decryptor_notification_cb_ = request_decryptor_notification_cb;
 
   StateTransitionTask(PIPELINE_OK);
 }
 
 void Pipeline::StopTask(const base::Closure& stop_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(stop_cb_.is_null());
 
   if (state_ == kStopped) {
     stop_cb.Run();
@@ skipping 162 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   DCHECK(stream);
 
   filter_collection_->SelectAudioRenderer(&audio_renderer_);
   audio_renderer_->Initialize(
       stream,
       *filter_collection_->GetAudioDecoders(),
+      request_decryptor_notification_cb_,

[scherkus (not reviewing), 2012/12/11 20:52:15]

why does this have to go in via Initialize() versus ctor?

[xhwang, 2012/12/12 23:43:28]

That's actually my first attempt. It didn't work well because in
render_view_impl
(http://code.google.com/searchframe#OAMlx_jo-ck/src/content/renderer/render_vi...),
we create the audio_renderer_impl also. In RenderViewImpl we don't have the
proxy_decryptor and the callback to pass in the ctor of AudioRendererImpl.

After I went the current approach, I started to like it. The callback is only
used in initialization of decoders and it makes sense to me to pass it in the
Init() call. WDYT?

       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, this),
       base::Bind(&Pipeline::OnAudioUnderflow, this),
       base::Bind(&Pipeline::OnAudioTimeUpdate, this),
       base::Bind(&Pipeline::OnAudioRendererEnded, this),
       base::Bind(&Pipeline::OnAudioDisabled, this),
       base::Bind(&Pipeline::SetError, this));
   filter_collection_->GetAudioDecoders()->clear();
 }
 
@@ skipping 43 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media