Remove VideoDecodeAccelerator::SetCdm() and pass the cdm in Initialize()

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 318 matching lines @@
   if (!media_drm_bridge_cdm_context_)
     return;
 
   DCHECK(cdm_registration_id_);
   media_drm_bridge_cdm_context_->UnregisterPlayer(cdm_registration_id_);
 #endif  // defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
                                                Client* client) {
+  DVLOG(1) << __FUNCTION__ << ": " << config.AsHumanReadableString();
+  TRACE_EVENT0("media", "AVDA::Initialize");
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
-  TRACE_EVENT0("media", "AVDA::Initialize");
-
-  DVLOG(1) << __FUNCTION__ << ": " << config.AsHumanReadableString();
 
   if (make_context_current_cb_.is_null() || get_gles2_decoder_cb_.is_null()) {
-    NOTREACHED() << "GL callbacks are required for this VDA";
+    DLOG(ERROR) << "GL callbacks are required for this VDA";
     return false;
   }
 
   if (config.output_mode != Config::OutputMode::ALLOCATE) {
-    NOTREACHED() << "Only ALLOCATE OutputMode is supported by this VDA";
+    DLOG(ERROR) << "Only ALLOCATE OutputMode is supported by this VDA";
     return false;
   }
 
   DCHECK(client);
   client_ = client;
   codec_config_ = new CodecConfig();
   codec_config_->codec_ = VideoCodecProfileToVideoCodec(config.profile);
   codec_config_->initial_expected_coded_size_ =
       config.initial_expected_coded_size;
   is_encrypted_ = config.is_encrypted;
 
-  bool profile_supported = codec_config_->codec_ == media::kCodecVP8 ||
-                           codec_config_->codec_ == media::kCodecVP9 ||
-                           codec_config_->codec_ == media::kCodecH264;
-
   // We signalled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
 
-  if (!profile_supported) {
+  if (is_encrypted_ && !deferred_initialization_pending_) {
+    DLOG(ERROR) << "Deferred initialization must be used for encrypted streams";
+    return false;
+  }
+
+  if (codec_config_->codec_ != media::kCodecVP8 &&
+      codec_config_->codec_ != media::kCodecVP9 &&
+      codec_config_->codec_ != media::kCodecH264) {
     LOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
-  // For encrypted streams we postpone configuration until MediaCrypto is
-  // available.
-  DCHECK(!is_encrypted_ || deferred_initialization_pending_);
-
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // or if the stream is encrypted.
   if ((codec_config_->codec_ == media::kCodecVP8 ||
        codec_config_->codec_ == media::kCodecVP9) &&
       !is_encrypted_ &&
       media::VideoCodecBridge::IsKnownUnaccelerated(
           codec_config_->codec_, media::MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
              << (codec_config_->codec_ == media::kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
@@ skipping 36 matching lines @@
   scoped_refptr<gfx::SurfaceTexture> surface_texture =
       strategy_->GetSurfaceTexture();
   if (surface_texture) {
     on_frame_available_handler_ =
         new OnFrameAvailableHandler(this, surface_texture);
   }
 
   // Start the thread for async configuration, even if we don't need it now.
   // ResetCodecState might rebuild the codec later, for example.
   if (!g_avda_timer.Pointer()->StartThread(this)) {
-    LOG(ERROR) << "Failed to start thread for AVDA timer";
+    LOG(ERROR) << "Failed to start AVDA thread";
     return false;
   }
 
   // If we are encrypted, then we aren't able to create the codec yet.
-  if (is_encrypted_)
+  if (is_encrypted_) {
+    InitializeCdm(config.cdm_id);
     return true;
+  }
 
   if (deferred_initialization_pending_) {
     ConfigureMediaCodecAsynchronously();
     return true;
   }
 
   // If the client doesn't support deferred initialization (WebRTC), then we
   // should complete it now and return a meaningful result.
   return ConfigureMediaCodecSynchronously();
 }
 
-void AndroidVideoDecodeAccelerator::SetCdm(int cdm_id) {
-  DVLOG(2) << __FUNCTION__ << ": " << cdm_id;
-
-#if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-  DCHECK(client_) << "SetCdm() must be called after Initialize().";
-
-  if (media_drm_bridge_cdm_context_) {
-    NOTREACHED() << "We do not support resetting CDM.";
-    NotifyInitializationComplete(false);
-    return;
-  }
-
-  // Store the CDM to hold a reference to it.
-  cdm_for_reference_holding_only_ = media::MojoCdmService::LegacyGetCdm(cdm_id);
-  DCHECK(cdm_for_reference_holding_only_);
-
-  // On Android platform the CdmContext must be a MediaDrmBridgeCdmContext.
-  media_drm_bridge_cdm_context_ = static_cast<media::MediaDrmBridgeCdmContext*>(
-      cdm_for_reference_holding_only_->GetCdmContext());
-  DCHECK(media_drm_bridge_cdm_context_);
-
-  // Register CDM callbacks. The callbacks registered will be posted back to
-  // this thread via BindToCurrentLoop.
-
-  // Since |this| holds a reference to the |cdm_|, by the time the CDM is
-  // destructed, UnregisterPlayer() must have been called and |this| has been
-  // destructed as well. So the |cdm_unset_cb| will never have a chance to be
-  // called.
-  // TODO(xhwang): Remove |cdm_unset_cb| after it's not used on all platforms.
-  cdm_registration_id_ = media_drm_bridge_cdm_context_->RegisterPlayer(
-      media::BindToCurrentLoop(
-          base::Bind(&AndroidVideoDecodeAccelerator::OnKeyAdded,
-                     weak_this_factory_.GetWeakPtr())),
-      base::Bind(&base::DoNothing));
-
-  media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(media::BindToCurrentLoop(
-      base::Bind(&AndroidVideoDecodeAccelerator::OnMediaCryptoReady,
-                 weak_this_factory_.GetWeakPtr())));
-
-// Postpone NotifyInitializationComplete() call till we create the MediaCodec
-// after OnMediaCryptoReady().
-#else
-
-  NOTIMPLEMENTED();
-  NotifyInitializationComplete(false);
-
-#endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-}
-
 void AndroidVideoDecodeAccelerator::DoIOTask(bool start_timer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DoIOTask");
   if (state_ == ERROR || state_ == WAITING_FOR_CODEC)
     return;
 
   strategy_->MaybeRenderEarly();
   bool did_work = false, did_input = false, did_output = false;
   do {
     did_input = QueueInput();
@@ skipping 778 matching lines @@
     const ::tracked_objects::Location& from_here,
     media::VideoDecodeAccelerator::Error error) {
   base::MessageLoop::current()->PostDelayedTask(
       from_here,
       base::Bind(&AndroidVideoDecodeAccelerator::NotifyError,
                  weak_this_factory_.GetWeakPtr(), error, error_sequence_token_),
       (defer_errors_ ? ErrorPostingDelay() : base::TimeDelta()));
   state_ = ERROR;
 }
 
+void AndroidVideoDecodeAccelerator::InitializeCdm(int cdm_id) {
+  DVLOG(2) << __FUNCTION__ << ": " << cdm_id;
+
+#if !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
+  NOTIMPLEMENTED();
+  NotifyInitializationComplete(false);
+#else
+  // Store the CDM to hold a reference to it.
+  cdm_for_reference_holding_only_ = media::MojoCdmService::LegacyGetCdm(cdm_id);
+  DCHECK(cdm_for_reference_holding_only_);
+
+  // On Android platform the CdmContext must be a MediaDrmBridgeCdmContext.
+  media_drm_bridge_cdm_context_ = static_cast<media::MediaDrmBridgeCdmContext*>(
+      cdm_for_reference_holding_only_->GetCdmContext());
+  DCHECK(media_drm_bridge_cdm_context_);
+
+  // Register CDM callbacks. The callbacks registered will be posted back to
+  // this thread via BindToCurrentLoop.
+
+  // Since |this| holds a reference to the |cdm_|, by the time the CDM is
+  // destructed, UnregisterPlayer() must have been called and |this| has been
+  // destructed as well. So the |cdm_unset_cb| will never have a chance to be
+  // called.
+  // TODO(xhwang): Remove |cdm_unset_cb| after it's not used on all platforms.
+  cdm_registration_id_ = media_drm_bridge_cdm_context_->RegisterPlayer(
+      media::BindToCurrentLoop(
+          base::Bind(&AndroidVideoDecodeAccelerator::OnKeyAdded,
+                     weak_this_factory_.GetWeakPtr())),
+      base::Bind(&base::DoNothing));
+
+  // Deferred initialization will continue in OnMediaCryptoReady().
+  media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(media::BindToCurrentLoop(
+      base::Bind(&AndroidVideoDecodeAccelerator::OnMediaCryptoReady,
+                 weak_this_factory_.GetWeakPtr())));
+#endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
+}
+
 void AndroidVideoDecodeAccelerator::OnMediaCryptoReady(
     media::MediaDrmBridgeCdmContext::JavaObjectPtr media_crypto,
     bool needs_protected_surface) {
   DVLOG(1) << __FUNCTION__;
 
   if (!media_crypto) {
     LOG(ERROR) << "MediaCrypto is not available, can't play encrypted stream.";
     cdm_for_reference_holding_only_ = nullptr;
     media_drm_bridge_cdm_context_ = nullptr;
     NotifyInitializationComplete(false);
@@ skipping 151 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media