media: Make MediaKeys ref-counted.

media/base/android/media_source_player.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/base/android/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 21 matching lines @@
     : MediaPlayerAndroid(player_id,
                          manager,
                          on_decoder_resources_released_cb,
                          frame_url),
       demuxer_(demuxer.Pass()),
       pending_event_(NO_EVENT_PENDING),
       playing_(false),
       interpolator_(&default_tick_clock_),
       doing_browser_seek_(false),
       pending_seek_(false),
-      drm_bridge_(NULL),
+      drm_bridge_(nullptr),
       cdm_registration_id_(0),
       is_waiting_for_key_(false),
       key_added_while_decode_pending_(false),
       is_waiting_for_audio_decoder_(false),
       is_waiting_for_video_decoder_(false),
       prerolling_(true),
       weak_factory_(this) {
   media_stat_.reset(new MediaStatistics());
 
   audio_decoder_job_.reset(new AudioDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::AUDIO),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
                  weak_factory_.GetWeakPtr())));
   video_decoder_job_.reset(new VideoDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::VIDEO),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
                  weak_factory_.GetWeakPtr())));
 
   demuxer_->Initialize(this);
   interpolator_.SetUpperBound(base::TimeDelta());
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
-  DCHECK_EQ(!drm_bridge_, !cdm_registration_id_);
-  if (drm_bridge_) {
+  DCHECK_EQ(!cdm_, !cdm_registration_id_);
+  if (cdm_) {
     drm_bridge_->UnregisterPlayer(cdm_registration_id_);

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

Same consideration as with MediaCodecPlayer: I would use a cast and keep just
one member var that points to one object.

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

Done.

     cdm_registration_id_ = 0;
   }
 }
 
 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   DVLOG(1) << __FUNCTION__;
   if (!video_decoder_job_->SetVideoSurface(surface.Pass()))
     return;
   // Retry video decoder creation.
   RetryDecoderCreation(false, true);
@@ skipping 181 matching lines @@
     MediaDrmBridge::JavaObjectPtr /* media_crypto */,
     bool /* needs_protected_surface */) {
   // Callback parameters are ignored in this player. They are intended for
   // MediaCodecPlayer which uses a different threading scheme.
   DCHECK(!drm_bridge_->GetMediaCrypto().is_null());
 
   // Retry decoder creation if the decoders are waiting for MediaCrypto.
   RetryDecoderCreation(true, true);
 }
 
-void MediaSourcePlayer::SetCdm(BrowserCdm* cdm) {
+void MediaSourcePlayer::SetCdm(const scoped_refptr<MediaKeys>& cdm) {
+  DCHECK(cdm);
+
   // Currently we don't support DRM change during the middle of playback, even
   // if the player is paused.
   // TODO(qinmin): support DRM change after playback has started.
   // http://crbug.com/253792.
   if (GetCurrentTime() > base::TimeDelta()) {
     VLOG(0) << "Setting DRM bridge after playback has started. "
             << "This is not well supported!";
   }
 
-  if (drm_bridge_) {
+  if (cdm_) {
     NOTREACHED() << "Currently we do not support resetting CDM.";
     return;
   }
 
+  cdm_ = cdm;
+
   // Only MediaDrmBridge will be set on MediaSourcePlayer.
-  drm_bridge_ = static_cast<MediaDrmBridge*>(cdm);
+  drm_bridge_ = static_cast<MediaDrmBridge*>(cdm_.get());
 
   cdm_registration_id_ = drm_bridge_->RegisterPlayer(
       base::Bind(&MediaSourcePlayer::OnKeyAdded, weak_this_),
       base::Bind(&MediaSourcePlayer::OnCdmUnset, weak_this_));
 
   audio_decoder_job_->SetDrmBridge(drm_bridge_);
   video_decoder_job_->SetDrmBridge(drm_bridge_);
 
   if (drm_bridge_->GetMediaCrypto().is_null()) {
+    // Use BindToCurrentLoop to avoid reentrancy.
     MediaDrmBridge::MediaCryptoReadyCB cb = BindToCurrentLoop(
         base::Bind(&MediaSourcePlayer::OnMediaCryptoReady, weak_this_));
     drm_bridge_->SetMediaCryptoReadyCB(cb);
     return;
   }
 
   // If the player is previously waiting for CDM, retry decoder creation.
   RetryDecoderCreation(true, true);
 }
 
@@ skipping 518 matching lines @@
   key_added_while_decode_pending_ = false;
 
   // StartInternal() will trigger a prefetch, where in most cases we'll just
   // use previously received data.
   if (playing_)
     StartInternal();
 }
 
 void MediaSourcePlayer::OnCdmUnset() {
   DVLOG(1) << __FUNCTION__;
-  DCHECK(drm_bridge_);
+  DCHECK(cdm_);
   // 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).
-  audio_decoder_job_->SetDrmBridge(NULL);
-  video_decoder_job_->SetDrmBridge(NULL);
+  audio_decoder_job_->SetDrmBridge(nullptr);
+  video_decoder_job_->SetDrmBridge(nullptr);
   cdm_registration_id_ = 0;
-  drm_bridge_ = NULL;
+  drm_bridge_ = nullptr;
+  cdm_ = nullptr;
 }
 
 }  // namespace media