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/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 81 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_);

[Tima Vaisburd, 2015/10/28 22:49:40]

Can you use a cast from MediaKeys to MediaDemBridge? Then, I think, you can get
rid of |drm_bridge_| member variable.

   }
 }
 
 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) {
   RUN_ON_MEDIA_THREAD(SetCdm, cdm);
+  DCHECK(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.
+  drm_bridge_ = static_cast<MediaDrmBridge*>(cdm_.get());

[Tima Vaisburd, 2015/10/28 22:49:40]

I think we can get rid of |drm_bridge_|. See below.

[xhwang, 2015/10/29 00:17:28]

Done.

+
+  // Register CDM callbacks. The callbacks registered will be posted back to the
+  // media thread via BindToCurrentLoop.
 
   cdm_registration_id_ = drm_bridge_->RegisterPlayer(
-      base::Bind(&MediaCodecPlayer::OnKeyAdded, media_weak_this_),
-      base::Bind(&MediaCodecPlayer::OnCdmUnset, media_weak_this_));
+      BindToCurrentLoop(
+          base::Bind(&MediaCodecPlayer::OnKeyAdded, media_weak_this_)),
+      BindToCurrentLoop(
+          base::Bind(&MediaCodecPlayer::OnCdmUnset, media_weak_this_)));
 
-  MediaDrmBridge::MediaCryptoReadyCB cb = BindToCurrentLoop(
-      base::Bind(&MediaCodecPlayer::OnMediaCryptoReady, media_weak_this_));
-
-  // 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 522 matching lines @@
   if (audio_decoder_) {
     audio_decoder_->SetNeedsReconfigure();
   }
 
   if (video_decoder_) {
     video_decoder_->SetProtectedSurfaceRequired(false);
     video_decoder_->SetNeedsReconfigure();
   }
 
   cdm_registration_id_ = 0;
+  media_crypto_.reset();
   drm_bridge_ = nullptr;
-  media_crypto_.reset();
+  cdm_ = nullptr;
 }
 
 // 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;
 }
@@ skipping 416 matching lines @@
     RETURN_STRING(kStateWaitingForMediaCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media