Get CdmContext in MojoAudioDecoderService

media/mojo/services/mojo_audio_decoder_service.cc

 // Copyright 2016 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/mojo/services/mojo_audio_decoder_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "media/base/cdm_context.h"
+#include "media/base/media_keys.h"
 #include "media/mojo/common/media_type_converters.h"
+#include "media/mojo/services/mojo_cdm_service_context.h"
 
 namespace media {
 
 MojoAudioDecoderService::MojoAudioDecoderService(
+    base::WeakPtr<MojoCdmServiceContext> mojo_cdm_service_context,
     scoped_ptr<media::AudioDecoder> decoder,
     mojo::InterfaceRequest<interfaces::AudioDecoder> request)
     : binding_(this, std::move(request)),
+      mojo_cdm_service_context_(mojo_cdm_service_context),
       decoder_(std::move(decoder)),
       weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 MojoAudioDecoderService::~MojoAudioDecoderService() {}
 
 void MojoAudioDecoderService::Initialize(
     interfaces::AudioDecoderClientPtr client,
     interfaces::AudioDecoderConfigPtr config,
     int32_t cdm_id,
     const InitializeCallback& callback) {
   DVLOG(1) << __FUNCTION__ << " "
            << config.To<media::AudioDecoderConfig>().AsHumanReadableString();
 
-  // Encrypted streams are not supported for now.
-  if (config.To<media::AudioDecoderConfig>().is_encrypted() &&
-      cdm_id == CdmContext::kInvalidCdmId) {
-    // The client should prevent this situation.
-    NOTREACHED() << "Encrypted streams are not supported";
-    callback.Run(false, false);
-    return;
+  // Get CdmContext from cdm_id if the stream is encrypted.
+  CdmContext* cdm_context = nullptr;
+  if (config.To<media::AudioDecoderConfig>().is_encrypted()) {
+    if (!mojo_cdm_service_context_) {
+      DVLOG(1) << "CDM service context not available.";
+      callback.Run(false, false);
+      return;
+    }
+
+    scoped_refptr<MediaKeys> cdm = mojo_cdm_service_context_->GetCdm(cdm_id);
+    if (!cdm) {
+      DVLOG(1) << "CDM not found for CDM id: " << cdm_id;
+      callback.Run(false, false);
+      return;
+    }
+
+    cdm_context = cdm->GetCdmContext();
+    if (!cdm_context) {
+      DVLOG(1) << "CDM context not available for CDM id: " << cdm_id;
+      callback.Run(false, false);
+      return;
+    }
+
+    cdm_ = cdm;

[Tima Vaisburd, 2016/03/21 21:53:01]

I can bind |cdm| to OnInitialized() instead, but do we need to hold it for
decoder_->Initialize() as well?

[xhwang, 2016/03/21 22:31:23]

Either way is fine. When you bind |cdm| into the callback, the callback takes a
reference. The reference will only be dropped when the callback is fired and we
drop the |cdm| in OnInitialized() (instead saving it), or when the callback is
destroyed, e.g. when message loop is destructing.

[Tima Vaisburd, 2016/03/21 23:07:05]

That you, I missed the fact that Bind() will hold the reference. Using Bind
seems more elegant, I did that.

[xhwang, 2016/03/21 23:13:03]

Yes, this often results in more elegant code. But it has it's own drawbacks. For
example, if the task (bound callback) is posted to a different thread, and
somehow message loop destruction happens, the callback and all it's bound
parameters will be destroyed on that thread. If you have BindToCurrentLoop() and
you expect the callback to always be posted back because the bound parameter is
not thread safe, this will cause trouble. Just FYI :)

In this case we are fine because we are all on the same thread.

   }
 
   client_ = std::move(client);
 
-  // TODO(timav): Get CdmContext from cdm_id.
   decoder_->Initialize(
-      config.To<media::AudioDecoderConfig>(),
-      nullptr,  // no CdmContext
+      config.To<media::AudioDecoderConfig>(), cdm_context,
       base::Bind(&MojoAudioDecoderService::OnInitialized, weak_this_, callback),
       base::Bind(&MojoAudioDecoderService::OnAudioBufferReady, weak_this_));
 }
 
 void MojoAudioDecoderService::SetDataSource(
     mojo::ScopedDataPipeConsumerHandle receive_pipe) {
   DVLOG(1) << __FUNCTION__;
   consumer_handle_ = std::move(receive_pipe);
 }
 
 void MojoAudioDecoderService::Decode(interfaces::DecoderBufferPtr buffer,
                                      const DecodeCallback& callback) {
   DVLOG(3) << __FUNCTION__;
   decoder_->Decode(ReadDecoderBuffer(std::move(buffer)),
                    base::Bind(&MojoAudioDecoderService::OnDecodeStatus,
                               weak_this_, callback));
 }
 
 void MojoAudioDecoderService::Reset(const ResetCallback& callback) {
   DVLOG(1) << __FUNCTION__;
   decoder_->Reset(
       base::Bind(&MojoAudioDecoderService::OnResetDone, weak_this_, callback));
 }
 
 void MojoAudioDecoderService::OnInitialized(const InitializeCallback& callback,
                                             bool success) {
   DVLOG(1) << __FUNCTION__ << " success:" << success;
+
+  if (!success)
+    cdm_ = nullptr;
+
   callback.Run(success, decoder_->NeedsBitstreamConversion());
 }
 
 static interfaces::AudioDecoder::DecodeStatus ConvertDecodeStatus(
     media::AudioDecoder::Status status) {
   switch (status) {
     case media::AudioDecoder::kOk:
       return interfaces::AudioDecoder::DecodeStatus::OK;
     case media::AudioDecoder::kAborted:
       return interfaces::AudioDecoder::DecodeStatus::ABORTED;
@@ skipping 45 matching lines @@
   uint32_t bytes_read = bytes_to_read;
   CHECK_EQ(ReadDataRaw(consumer_handle_.get(), media_buffer->writable_data(),
                        &bytes_read, MOJO_READ_DATA_FLAG_ALL_OR_NONE),
            MOJO_RESULT_OK);
   CHECK_EQ(bytes_to_read, bytes_read);
 
   return media_buffer;
 }
 
 }  // namespace media