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"
 #include "base/barrier_closure.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/android/audio_decoder_job.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/video_decoder_job.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 MediaSourcePlayer::MediaSourcePlayer(
     int player_id,
     MediaPlayerManager* manager,
     const OnDecoderResourcesReleasedCB& on_decoder_resources_released_cb,
     scoped_ptr<DemuxerAndroid> demuxer,
     const GURL& frame_url)
     : 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),
       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_) {
-    drm_bridge_->UnregisterPlayer(cdm_registration_id_);
+  DCHECK_EQ(!cdm_, !cdm_registration_id_);
+  if (cdm_) {
+    static_cast<MediaDrmBridge*>(cdm_.get())
+        ->UnregisterPlayer(cdm_registration_id_);
     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 175 matching lines @@
 
 void MediaSourcePlayer::OnDemuxerDurationChanged(base::TimeDelta duration) {
   duration_ = duration;
 }
 
 void MediaSourcePlayer::OnMediaCryptoReady(
     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());
+  DCHECK(!static_cast<MediaDrmBridge*>(cdm_.get())->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);
+  MediaDrmBridge* drm_bridge = static_cast<MediaDrmBridge*>(cdm_.get());
 
-  cdm_registration_id_ = drm_bridge_->RegisterPlayer(
+  // No need to set |cdm_unset_cb| since |this| holds a reference to the |cdm_|.
+  cdm_registration_id_ = drm_bridge->RegisterPlayer(
       base::Bind(&MediaSourcePlayer::OnKeyAdded, weak_this_),
-      base::Bind(&MediaSourcePlayer::OnCdmUnset, weak_this_));
+      base::Bind(&base::DoNothing));
 
-  audio_decoder_job_->SetDrmBridge(drm_bridge_);
-  video_decoder_job_->SetDrmBridge(drm_bridge_);
+  audio_decoder_job_->SetDrmBridge(drm_bridge);
+  video_decoder_job_->SetDrmBridge(drm_bridge);
 
-  if (drm_bridge_->GetMediaCrypto().is_null()) {
+  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);
+    drm_bridge->SetMediaCryptoReadyCB(cb);
     return;
   }
 
   // If the player is previously waiting for CDM, retry decoder creation.
   RetryDecoderCreation(true, true);
 }
 
 void MediaSourcePlayer::OnDemuxerSeekDone(
     base::TimeDelta actual_browser_seek_time) {
   DVLOG(1) << __FUNCTION__;
@@ skipping 513 matching lines @@
 
   is_waiting_for_key_ = false;
   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_);
-  // 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);
-  cdm_registration_id_ = 0;
-  drm_bridge_ = NULL;
-}
-
 }  // namespace media