Add PlayerTracker and BrowserCdm interfaces.

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 36 matching lines @@
       is_audio_encrypted_(false),
       is_video_encrypted_(false),
       volume_(-1.0),
       clock_(&default_tick_clock_),
       next_video_data_is_iframe_(true),
       doing_browser_seek_(false),
       pending_seek_(false),
       reconfig_audio_decoder_(false),
       reconfig_video_decoder_(false),
       drm_bridge_(NULL),
+      cdm_registration_id_(0),
       is_waiting_for_key_(false),
       has_pending_audio_data_request_(false),
       has_pending_video_data_request_(false),
       weak_factory_(this) {
   demuxer_->Initialize(this);
   clock_.SetMaxTime(base::TimeDelta());
+  weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
+  if (drm_bridge_) {
+    DCHECK_NE(cdm_registration_id_, 0);

[ddorwin, 2014/06/02 20:20:29]

If you want a DCHECK, it's probably something like EQ(!drm_bridge_,
!cdm_registration_id_) above line 69.

[xhwang, 2014/06/02 21:41:22]

Done.

+    drm_bridge_->UnregisterPlayer(cdm_registration_id_);
+    cdm_registration_id_ = 0;
+  }
 }
 
 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   // For an empty surface, always pass it to the decoder job so that it
   // can detach from the current one. Otherwise, don't pass an unprotected
   // surface if the video content requires a protected one.
   if (!surface.IsEmpty() &&
       IsProtectedSurfaceRequired() && !surface.is_protected()) {
     return;
   }
@@ skipping 155 matching lines @@
     DVLOG(1) << __FUNCTION__ << " : Resuming seek or config change processing";
     ProcessPendingEvents();
   }
 }
 
 void MediaSourcePlayer::SetVolume(double volume) {
   volume_ = volume;
   SetVolumeInternal();
 }
 
-void MediaSourcePlayer::OnKeyAdded() {
-  DVLOG(1) << __FUNCTION__;
-  if (!is_waiting_for_key_)
-    return;
-
-  is_waiting_for_key_ = false;
-  if (playing_)
-    StartInternal();
-}
-
 bool MediaSourcePlayer::IsSurfaceInUse() const {
   return is_surface_in_use_;
 }
 
 bool MediaSourcePlayer::CanPause() {
   return Seekable();
 }
 
 bool MediaSourcePlayer::CanSeekForward() {
   return Seekable();
@@ skipping 86 matching lines @@
 }
 
 void MediaSourcePlayer::OnMediaCryptoReady() {
   DCHECK(!drm_bridge_->GetMediaCrypto().is_null());
   drm_bridge_->SetMediaCryptoReadyCB(base::Closure());
 
   if (playing_)
     StartInternal();
 }
 
-void MediaSourcePlayer::SetCdm(MediaKeys* cdm) {
+void MediaSourcePlayer::SetCdm(BrowserCdm* 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_) {
+    NOTREACHED() << "Currently we do not support resetting CDM.";
+    return;
+  }
+
   // Only MediaDrmBridge will be set on MediaSourcePlayer.
   drm_bridge_ = static_cast<MediaDrmBridge*>(cdm);
 
+  cdm_registration_id_ = drm_bridge_->RegisterPlayer(
+      base::Bind(&MediaSourcePlayer::OnKeyAdded, weak_this_),
+      base::Bind(&MediaSourcePlayer::OnCdmUnset, weak_this_));
+
   if (drm_bridge_->GetMediaCrypto().is_null()) {
-    drm_bridge_->SetMediaCryptoReadyCB(base::Bind(
-        &MediaSourcePlayer::OnMediaCryptoReady, weak_factory_.GetWeakPtr()));
+    drm_bridge_->SetMediaCryptoReadyCB(
+        base::Bind(&MediaSourcePlayer::OnMediaCryptoReady, weak_this_));
     return;
   }
 
   if (playing_)
     StartInternal();
 }
 
 void MediaSourcePlayer::OnDemuxerSeekDone(
     base::TimeDelta actual_browser_seek_time) {
   DVLOG(1) << __FUNCTION__;
@@ skipping 133 matching lines @@
     int count = (AudioFinished() ? 0 : 1) + (VideoFinished() ? 0 : 1);
 
     // It is possible that all streams have finished decode, yet starvation
     // occurred during the last stream's EOS decode. In this case, prefetch is a
     // no-op.
     ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
     if (count == 0)
       return;
 
     SetPendingEvent(PREFETCH_DONE_EVENT_PENDING);
-    base::Closure barrier =
-        BarrierClosure(count,
-                       base::Bind(&MediaSourcePlayer::OnPrefetchDone,
-                                  weak_factory_.GetWeakPtr()));
+    base::Closure barrier = BarrierClosure(
+        count, base::Bind(&MediaSourcePlayer::OnPrefetchDone, weak_this_));
 
     if (!AudioFinished())
       audio_decoder_job_->Prefetch(barrier);
 
     if (!VideoFinished())
       video_decoder_job_->Prefetch(barrier);
 
     return;
   }
 
@@ skipping 107 matching lines @@
 }
 
 void MediaSourcePlayer::DecodeMoreAudio() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!audio_decoder_job_->is_decoding());
   DCHECK(!AudioFinished());
 
   scoped_ptr<DemuxerConfigs> configs(audio_decoder_job_->Decode(
       start_time_ticks_,
       start_presentation_timestamp_,
-      base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
-                 weak_factory_.GetWeakPtr(),
-                 true)));
+      base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_, true)));
   if (!configs) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio",
                              audio_decoder_job_.get());
     return;
   }
 
   // Failed to start the next decode.
   DCHECK(!reconfig_audio_decoder_);
   reconfig_audio_decoder_ = true;
   SetDemuxerConfigs(*configs, true);
 
   // Config change may have just been detected on the other stream. If so,
   // don't send a duplicate demuxer config request.
   if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) {
     DCHECK(reconfig_video_decoder_);
     return;
   }
 
   SetPendingEvent(CONFIG_CHANGE_EVENT_PENDING);
 }
 
 void MediaSourcePlayer::DecodeMoreVideo() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!video_decoder_job_->is_decoding());
   DCHECK(!VideoFinished());
 
   scoped_ptr<DemuxerConfigs> configs(video_decoder_job_->Decode(
       start_time_ticks_,
       start_presentation_timestamp_,
-      base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
-                 weak_factory_.GetWeakPtr(),
-                 false)));
+      base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_, false)));
   if (!configs) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreVideo",
                              video_decoder_job_.get());
     return;
   }
 
   // Failed to start the next decode.
   // After this detection of video config change, next video data received
   // will begin with I-frame.
   next_video_data_is_iframe_ = true;
@@ skipping 204 matching lines @@
     // For video only streams, fps can be estimated from the difference
     // between the previous and current presentation timestamps. The
     // previous presentation timestamp is equal to current_timestamp.
     // TODO(qinmin): determine whether 2 is a good coefficient for estimating
     // video frame timeout.
     timeout = 2 * (current_presentation_timestamp - current_timestamp);
   }
 
   timeout = std::max(timeout, kMinStarvationTimeout);
 
-  decoder_starvation_callback_.Reset(base::Bind(
-      &MediaSourcePlayer::OnDecoderStarved, weak_factory_.GetWeakPtr()));
+  decoder_starvation_callback_.Reset(
+      base::Bind(&MediaSourcePlayer::OnDecoderStarved, weak_this_));
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, decoder_starvation_callback_.callback(), timeout);
 }
 
 void MediaSourcePlayer::SetVolumeInternal() {
   if (audio_decoder_job_ && volume_ >= 0)
     audio_decoder_job_->SetVolume(volume_);
 }
 
 bool MediaSourcePlayer::IsProtectedSurfaceRequired() {
@@ skipping 86 matching lines @@
     is_audio_encrypted_ = configs.is_audio_encrypted;
     audio_extra_data_ = configs.audio_extra_data;
   } else {
     video_codec_ = configs.video_codec;
     width_ = configs.video_size.width();
     height_ = configs.video_size.height();
     is_video_encrypted_ = configs.is_video_encrypted;
   }
 }
 
+void MediaSourcePlayer::OnKeyAdded() {
+  DVLOG(1) << __FUNCTION__;
+  if (!is_waiting_for_key_)
+    return;
+
+  is_waiting_for_key_ = false;
+  if (playing_)
+    StartInternal();
+}
+
+void MediaSourcePlayer::OnCdmUnset() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(drm_bridge_);
+  // TODO(xhwang): Support detachment of CDM.
+  DVLOG(1) << "CDM detachment not supported.";
+}
+
 }  // namespace media