media: Remove SetCdmReadyCB and CdmReadyCB (part 1).

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace media {
 
 const char GpuVideoDecoder::kDecoderName[] = "GpuVideoDecoder";
@@ skipping 90 matching lines @@
       "Media.GpuVideoDecoderInitializeStatus", status, PIPELINE_STATUS_MAX + 1);
   cb.Run(success);
 }
 
 std::string GpuVideoDecoder::GetDisplayName() const {
   return kDecoderName;
 }
 
 void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  bool /* low_delay */,
-                                 const SetCdmReadyCB& set_cdm_ready_cb,
+                                 CdmContext* cdm_context,
                                  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 48 matching lines @@
 
   VideoDecodeAccelerator::Config vda_config(config);
 
   if (!vda_ || !vda_->Initialize(vda_config, this)) {
     DVLOG(1) << "VDA initialization failed.";
     bound_init_cb.Run(false);
     return;
   }
 
   if (config.is_encrypted()) {
+    DCHECK(cdm_context);
+    // No need to store |cdm_context| since it's not needed in reinitialization.
+    if (cdm_context->GetCdmId() == CdmContext::kInvalidCdmId) {
+      DVLOG(1) << "CDM ID not available.";
+      bound_init_cb.Run(false);
+      return;
+    }
+
+    // |init_cb_| will be fired when CDM is attached.
     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())));
+    vda_->SetCdm(cdm_context->GetCdmId());
     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());
   }
 
@@ skipping 352 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_t, PendingDecoderBuffer>::iterator it =
            bitstream_buffers_in_decoder_.begin();
@@ skipping 63 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media