media: Support SetCdm() on GpuVideoDecoder.

media/filters/gpu_video_decoder.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/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 103 matching lines @@
   PipelineStatus status = success ? PIPELINE_OK : DECODER_ERROR_NOT_SUPPORTED;
   UMA_HISTOGRAM_ENUMERATION(
       "Media.GpuVideoDecoderInitializeStatus", status, PIPELINE_STATUS_MAX + 1);
   cb.Run(success);
 }
 
 std::string GpuVideoDecoder::GetDisplayName() const {
   return kDecoderName;
 }
 
-// TODO(xhwang): Support CDM setting using |set_cdm_ready_cb|.
 void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  bool /* low_delay */,
-                                 const SetCdmReadyCB& /* set_cdm_ready_cb */,
+                                 const SetCdmReadyCB& set_cdm_ready_cb,
                                  const InitCB& init_cb,
                                  const OutputCB& output_cb) {
   DVLOG(3) << "Initialize()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(config.IsValidConfig());
 
   InitCB bound_init_cb =
       base::Bind(&ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB,
                  BindToCurrentLoop(init_cb));
 
@@ skipping 11 matching lines @@
 
   // TODO(posciak): destroy and create a new VDA on codec/profile change
   // (http://crbug.com/260224).
   if (previously_initialized && (config_.profile() != config.profile())) {
     DVLOG(1) << "Codec or profile changed, cannot reinitialize.";
     bound_init_cb.Run(false);
     return;
   }
 
   if (!IsProfileSupported(config.profile(), config.coded_size())) {
+    DVLOG(1) << "Profile " << config.profile() << " or coded size "
+             << config.coded_size().ToString() << " not supported.";
     bound_init_cb.Run(false);
     return;
   }
 
   config_ = config;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
   output_cb_ = BindToCurrentLoop(output_cb);
 
   if (previously_initialized) {
     // Reinitialization with a different config (but same codec and profile).
     // VDA should handle it by detecting this in-stream by itself,
     // no need to notify it.
     bound_init_cb.Run(true);
     return;
   }
 
   vda_ = factories_->CreateVideoDecodeAccelerator().Pass();
   if (!vda_ || !vda_->Initialize(config.profile(), this)) {
+    DVLOG(1) << "VDA initialization failed.";
     bound_init_cb.Run(false);
     return;
   }
 
+  if (config.is_encrypted()) {
+    init_cb_ = bound_init_cb;
+    set_cdm_ready_cb_ = set_cdm_ready_cb;
+    set_cdm_ready_cb_.Run(BindToCurrentLoop(
+        base::Bind(&GpuVideoDecoder::SetCdm, weak_factory_.GetWeakPtr())));
+    return;
+  }
+
   DVLOG(3) << "GpuVideoDecoder::Initialize() succeeded.";
   bound_init_cb.Run(true);
 }
 
+void GpuVideoDecoder::SetCdm(CdmContext* cdm_context,
+                             const CdmAttachedCB& cdm_attached_cb) {
+  DVLOG(2) << __FUNCTION__;
+  DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
+
+  DCHECK(!init_cb_.is_null());
+  DCHECK(!set_cdm_ready_cb_.is_null());
+  set_cdm_ready_cb_.Reset();
+
+  if (!cdm_context || cdm_context->GetCdmId() == CdmContext::kInvalidCdmId) {
+    DVLOG(1) << "CDM ID not available.";
+    cdm_attached_cb.Run(false);
+    base::ResetAndReturn(&init_cb_).Run(false);
+    return;
+  }
+
+  cdm_attached_cb_ = cdm_attached_cb;
+  vda_->SetCdm(cdm_context->GetCdmId());
+}
+
+void GpuVideoDecoder::NotifyCdmAttached(bool success) {
+  DVLOG_IF(2, !success) << __FUNCTION__ << ": CDM not attached.";
+  DCHECK(!init_cb_.is_null());
+  DCHECK(!cdm_attached_cb_.is_null());
+
+  base::ResetAndReturn(&cdm_attached_cb_).Run(success);
+  base::ResetAndReturn(&init_cb_).Run(success);
+}
+
 void GpuVideoDecoder::DestroyPictureBuffers(PictureBufferMap* buffers) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   for (PictureBufferMap::iterator it = buffers->begin(); it != buffers->end();
        ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
 
   buffers->clear();
 }
 
@@ skipping 343 matching lines @@
 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
   DVLOG(3) << __FUNCTION__;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (vda_)
     DestroyVDA();
   DCHECK(assigned_picture_buffers_.empty());
 
+  if (!set_cdm_ready_cb_.is_null())
+    base::ResetAndReturn(&set_cdm_ready_cb_).Run(CdmReadyCB());
+  if (!cdm_attached_cb_.is_null())
+    base::ResetAndReturn(&cdm_attached_cb_).Run(false);
+  if (!init_cb_.is_null())
+    base::ResetAndReturn(&init_cb_).Run(false);
+
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     delete available_shm_segments_[i];
   }
   available_shm_segments_.clear();
 
   for (std::map<int32, PendingDecoderBuffer>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     delete it->second.shm_buffer;
     it->second.done_cb.Run(kAborted);
@@ skipping 50 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media