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_)
+    drm_bridge_->UnregisterPlayer(cdm_registration_id_);

[ddorwin, 2014/05/30 20:50:05]

Should this be called even if cdm_registration_id_ == 0?
I believe it must be non-0 iff drm_bridge_ is not null. In that case, maybe
these calls should be grouped.

[xhwang, 2014/06/02 20:11:43]

Done.

+  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!";
   }
 
+  // Currently we don't support resetting |drm_bridge_|.

[ddorwin, 2014/05/30 20:50:05]

Ditto about DCHECK and error reporting.

[xhwang, 2014/06/02 20:11:43]

Done.

+  if (drm_bridge_)
+    return;
+
   // Only MediaDrmBridge will be set on MediaSourcePlayer.
   drm_bridge_ = static_cast<MediaDrmBridge*>(cdm);
 
+  cdm_registration_id_ = cdm->RegisterPlayer(

[ddorwin, 2014/05/30 20:50:05]

A bit odd to cast then use the previous pointer (cdm). Note that Unregister is
called on the member.

[xhwang, 2014/06/02 20:11:43]

Done.

+      base::Bind(&MediaSourcePlayer::OnKeyAdded, weak_this_),
+      base::Bind(&MediaSourcePlayer::OnCdmDestroyed, weak_this_));
+
   if (drm_bridge_->GetMediaCrypto().is_null()) {

[ddorwin, 2014/05/30 20:50:05]

Should this logic be made generic as well? Some type of OnInitializedCB?

[xhwang, 2014/06/02 20:11:43]

Not sure whether there's a general need for this. We need it here because the
creation of MediaCypto object could be delayed (e.g. due to provisioning).
However, other platforms may not need this at all. I'd like to keep this code as
is until we have another platform needs something similar.

-    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::OnCdmDestroyed() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(drm_bridge_);
+  // TODO(xhwang): Support detachment of CDM.

[ddorwin, 2014/05/30 20:50:05]

Don't you need to handle the platform-driven case (sleep) now?

[xhwang, 2014/06/02 20:11:43]

That'll be a non-trivial change. I'll probably do that later.

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

But does this break existing prefixed API behavior on Chrome for Android?

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

Currently we are not releasing MediaDrm when the devise goes to sleep. In the
future we need to fix this. Added TODO.

+  DVLOG(1) << "CDM detachment not supported.";
+}
+
 }  // namespace media