media: Make MediaKeys ref-counted.

media/base/android/media_codec_player.cc

 // Copyright 2015 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/android/media_codec_player.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "media/base/android/media_codec_audio_decoder.h"
 #include "media/base/android/media_codec_video_decoder.h"
 #include "media/base/android/media_drm_bridge.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_task_runner.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 23 matching lines @@
     : MediaPlayerAndroid(player_id,
                          manager.get(),
                          on_decoder_resources_released_cb,
                          frame_url),
       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       demuxer_(demuxer.Pass()),
       state_(kStatePaused),
       interpolator_(&default_tick_clock_),
       pending_start_(false),
       pending_seek_(kNoTimestamp()),
-      drm_bridge_(nullptr),
       cdm_registration_id_(0),
       key_is_required_(false),
       key_is_added_(false),
       media_weak_factory_(this) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "MediaCodecPlayer::MediaCodecPlayer: player_id:" << player_id;
 
   completion_cb_ =
       base::Bind(&MediaPlayerManager::OnPlaybackComplete, manager, player_id);
@@ skipping 29 matching lines @@
   // Release the codecs here, before any member variable is destroyed to make
   // the unit tests happy.
 
   if (video_decoder_)
     video_decoder_->ReleaseDecoderResources();
   if (audio_decoder_)
     audio_decoder_->ReleaseDecoderResources();
 
   media_stat_->StopAndReport(GetInterpolatedTime());
 
-  if (drm_bridge_) {
+  if (cdm_) {
     DCHECK(cdm_registration_id_);
-    drm_bridge_->UnregisterPlayer(cdm_registration_id_);
+    static_cast<MediaDrmBridge*>(cdm_.get())
+        ->UnregisterPlayer(cdm_registration_id_);
   }
 }
 
 void MediaCodecPlayer::Initialize() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   interpolator_.SetUpperBound(base::TimeDelta());
 
   CreateDecoders();
@@ skipping 288 matching lines @@
   return false;
 }
 
 bool MediaCodecPlayer::IsPlayerReady() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   // This method is called to check whether it's safe to release the player when
   // the OS needs more resources. This class can be released at any time.
   return true;
 }
 
-void MediaCodecPlayer::SetCdm(BrowserCdm* cdm) {
+void MediaCodecPlayer::SetCdm(const scoped_refptr<MediaKeys>& cdm) {
+  DCHECK(cdm);
   RUN_ON_MEDIA_THREAD(SetCdm, cdm);
 
   DVLOG(1) << __FUNCTION__;
 
   // Currently we don't support DRM change during the middle of playback, even
   // if the player is paused. There is no current plan to support it, see
   // http://crbug.com/253792.
   if (state_ != kStatePaused || GetInterpolatedTime() > base::TimeDelta()) {
     VLOG(0) << "Setting DRM bridge after playback has started is not supported";
     return;
   }
 
-  if (drm_bridge_) {
+  if (cdm_) {
     NOTREACHED() << "Currently we do not support resetting CDM.";
     return;
   }
 
-  DCHECK(cdm);
-  drm_bridge_ = static_cast<MediaDrmBridge*>(cdm);
+  cdm_ = cdm;
 
-  DCHECK(drm_bridge_);
+  // Only MediaDrmBridge will be set on MediaCodecPlayer.
+  MediaDrmBridge* drm_bridge = static_cast<MediaDrmBridge*>(cdm_.get());
 
-  cdm_registration_id_ = drm_bridge_->RegisterPlayer(
-      base::Bind(&MediaCodecPlayer::OnKeyAdded, media_weak_this_),
-      base::Bind(&MediaCodecPlayer::OnCdmUnset, media_weak_this_));
+  // Register CDM callbacks. The callbacks registered will be posted back to the
+  // media thread via BindToCurrentLoop.
 
-  MediaDrmBridge::MediaCryptoReadyCB cb = BindToCurrentLoop(
-      base::Bind(&MediaCodecPlayer::OnMediaCryptoReady, media_weak_this_));
+  // 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_ = drm_bridge->RegisterPlayer(
+      BindToCurrentLoop(
+          base::Bind(&MediaCodecPlayer::OnKeyAdded, media_weak_this_)),
+      base::Bind(&base::DoNothing));
 
-  // Post back to MediaDrmBridge's default thread.
-  ui_task_runner_->PostTask(FROM_HERE,
-                            base::Bind(&MediaDrmBridge::SetMediaCryptoReadyCB,
-                                       drm_bridge_->WeakPtr(), cb));
+  drm_bridge->SetMediaCryptoReadyCB(BindToCurrentLoop(
+      base::Bind(&MediaCodecPlayer::OnMediaCryptoReady, media_weak_this_)));
 }
 
 // Callbacks from Demuxer.
 
 void MediaCodecPlayer::OnDemuxerConfigsAvailable(
     const DemuxerConfigs& configs) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(1) << __FUNCTION__;
 
@@ skipping 501 matching lines @@
   DVLOG(1) << __FUNCTION__;
 
   key_is_added_ = true;
 
   if (state_ == kStateWaitingForKey) {
     SetState(kStatePlaying);
     StartPlaybackOrBrowserSeek();
   }
 }
 
-void MediaCodecPlayer::OnCdmUnset() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  // This comment is copied from MediaSourcePlayer::OnCdmUnset().
-  // TODO(xhwang): Currently this is only called during teardown. Support full
-  // detachment of CDM during playback. This will be needed when we start to
-  // support setMediaKeys(0) (see http://crbug.com/330324), or when we release
-  // MediaDrm when the video is paused, or when the device goes to sleep (see
-  // http://crbug.com/272421).
-
-  if (audio_decoder_) {
-    audio_decoder_->SetNeedsReconfigure();
-  }
-
-  if (video_decoder_) {
-    video_decoder_->SetProtectedSurfaceRequired(false);
-    video_decoder_->SetNeedsReconfigure();
-  }
-
-  cdm_registration_id_ = 0;
-  drm_bridge_ = nullptr;
-  media_crypto_.reset();
-}
-
 // State machine operations, called on Media thread
 
 void MediaCodecPlayer::SetState(PlayerState new_state) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(1) << "SetState:" << AsString(state_) << " -> " << AsString(new_state);
   state_ = new_state;
 }
 
 void MediaCodecPlayer::SetPendingStart(bool need_to_start) {
@@ skipping 414 matching lines @@
     RETURN_STRING(kStateWaitingForMediaCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media