MediaCodecPlayer implementation - stage 7 (DRM)

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"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "media/base/android/media_codec_audio_decoder.h"
 #include "media/base/android/media_codec_video_decoder.h"
+#include "media/base/android/media_drm_bridge.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_task_runner.h"
 #include "media/base/timestamp_constants.h"
 
 #define RUN_ON_MEDIA_THREAD(METHOD, ...)                                     \
   do {                                                                       \
     if (!GetMediaTaskRunner()->BelongsToCurrentThread()) {                   \
       DCHECK(ui_task_runner_->BelongsToCurrentThread());                     \
       GetMediaTaskRunner()->PostTask(                                        \
           FROM_HERE, base::Bind(&MediaCodecPlayer::METHOD, media_weak_this_, \
@@ skipping 15 matching lines @@
     : MediaPlayerAndroid(player_id,
                          manager.get(),
                          request_media_resources_cb,
                          frame_url),
       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       demuxer_(demuxer.Pass()),
       state_(kStatePaused),
       interpolator_(&default_tick_clock_),
       pending_start_(false),
       pending_seek_(kNoTimestamp()),
+      drm_bridge_(nullptr),
+      cdm_registration_id_(0),
+      key_is_required_(false),
+      key_is_added_(false),
       media_weak_factory_(this) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "MediaCodecPlayer::MediaCodecPlayer: player_id:" << player_id;
 
   request_resources_cb_ = base::Bind(request_media_resources_cb_, player_id);
 
   completion_cb_ =
       base::Bind(&MediaPlayerManager::OnPlaybackComplete, manager, player_id);
+  key_required_cb_ = base::Bind(&MediaPlayerManager::OnWaitingForDecryptionKey,
+                                manager, player_id);
   seek_done_cb_ =
       base::Bind(&MediaPlayerManager::OnSeekComplete, manager, player_id);
   error_cb_ = base::Bind(&MediaPlayerManager::OnError, manager, player_id);
 
   attach_listener_cb_ = base::Bind(&MediaPlayerAndroid::AttachListener,
                                    WeakPtrForUIThread(), nullptr);
   detach_listener_cb_ =
       base::Bind(&MediaPlayerAndroid::DetachListener, WeakPtrForUIThread());
   metadata_changed_cb_ = base::Bind(&MediaPlayerAndroid::OnMediaMetadataChanged,
                                     WeakPtrForUIThread());
@@ skipping 14 matching lines @@
 
   // Currently the unit tests wait for the MediaCodecPlayer destruction by
   // watching the demuxer, which is destroyed as one of the member variables.
   // 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();
+
+  if (drm_bridge_) {
+    DCHECK(cdm_registration_id_);
+    drm_bridge_->UnregisterPlayer(cdm_registration_id_);
+  }
 }
 
 void MediaCodecPlayer::Initialize() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   interpolator_.SetUpperBound(base::TimeDelta());
 
   CreateDecoders();
 
@@ skipping 27 matching lines @@
   // Save the empty-ness before we pass the surface to the decoder.
   bool surface_is_empty = surface.IsEmpty();
 
   // Apparently RemoveVideoSurface() can be called several times in a row,
   // ignore the second and subsequent calls.
   if (surface_is_empty && !video_decoder_->HasVideoSurface()) {
     DVLOG(1) << __FUNCTION__ << ": surface already removed, ignoring";
     return;
   }
 
+  // Do not set unprotected surface if we know that we need a protected one.
+  // Empty surface means the surface removal and we always allow for it.
+  if (!surface_is_empty && video_decoder_->IsProtectedSurfaceRequired() &&
+      !surface.is_protected()) {
+    DVLOG(0) << __FUNCTION__ << ": surface is not protected, ignoring";
+    return;
+  }
+
   video_decoder_->SetVideoSurface(surface.Pass());
 
   if (surface_is_empty) {
     // Remove video surface.
     switch (state_) {
       case kStatePlaying:
         if (VideoFinished())
           break;
 
         DVLOG(1) << __FUNCTION__ << ": stopping and restarting";
@@ skipping 53 matching lines @@
       break;
     case kStateStopping:
     case kStateWaitingForSeek:
       SetPendingStart(true);
       break;
     case kStateWaitingForConfig:
     case kStateWaitingForPermission:
     case kStatePrefetching:
     case kStatePlaying:
     case kStateWaitingForSurface:
+    case kStateWaitingForKey:
+    case kStateWaitingForCrypto:
     case kStateError:
       break;  // Ignore
     default:
       NOTREACHED();
       break;
   }
 }
 
 void MediaCodecPlayer::Pause(bool is_media_related_action) {
   RUN_ON_MEDIA_THREAD(Pause, is_media_related_action);
 
   DVLOG(1) << __FUNCTION__;
 
   SetPendingStart(false);
 
   switch (state_) {
     case kStateWaitingForConfig:
     case kStateWaitingForPermission:
     case kStatePrefetching:
     case kStateWaitingForSurface:
+    case kStateWaitingForKey:
+    case kStateWaitingForCrypto:
       SetState(kStatePaused);
       StopDecoders();
       break;
     case kStatePlaying:
       SetState(kStateStopping);
       RequestToStopDecoders();
       break;
     case kStatePaused:
     case kStateStopping:
     case kStateWaitingForSeek:
@@ skipping 12 matching lines @@
 
   switch (state_) {
     case kStatePaused:
       SetState(kStateWaitingForSeek);
       RequestDemuxerSeek(timestamp);
       break;
     case kStateWaitingForConfig:
     case kStateWaitingForPermission:
     case kStatePrefetching:
     case kStateWaitingForSurface:
+    case kStateWaitingForKey:
+    case kStateWaitingForCrypto:
       SetState(kStateWaitingForSeek);
       StopDecoders();
       SetPendingStart(true);
       RequestDemuxerSeek(timestamp);
       break;
     case kStatePlaying:
       SetState(kStateStopping);
       RequestToStopDecoders();
       SetPendingStart(true);
       SetPendingSeek(timestamp);
@@ skipping 20 matching lines @@
   // Stop decoding threads and delete MediaCodecs, but keep IPC between browser
   // and renderer processes going. Seek should work across and after Release().
 
   ReleaseDecoderResources();
 
   SetPendingStart(false);
 
   if (state_ != kStateWaitingForSeek)
     SetState(kStatePaused);
 
+  // Crear encryption key related flags.
+  key_is_required_ = false;
+  key_is_added_ = false;
+
   base::TimeDelta pending_seek_time = GetPendingSeek();
   if (pending_seek_time != kNoTimestamp()) {
     SetPendingSeek(kNoTimestamp());
     SetState(kStateWaitingForSeek);
     RequestDemuxerSeek(pending_seek_time);
   }
 }
 
 void MediaCodecPlayer::SetVolume(double volume) {
   RUN_ON_MEDIA_THREAD(SetVolume, volume);
@@ skipping 49 matching lines @@
 }
 
 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) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
+  RUN_ON_MEDIA_THREAD(SetCdm, 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_) {
+    NOTREACHED() << "Currently we do not support resetting CDM.";
+    return;
+  }
+
+  DCHECK(cdm);
+  drm_bridge_ = static_cast<MediaDrmBridge*>(cdm);
+
+  DCHECK(drm_bridge_);
+
+  cdm_registration_id_ = drm_bridge_->RegisterPlayer(
+      base::Bind(&MediaCodecPlayer::OnKeyAdded, media_weak_this_),
+      base::Bind(&MediaCodecPlayer::OnCdmUnset, media_weak_this_));
+
+  MediaDrmBridge::MediaCryptoReadyCB cb =
+      base::Bind(&MediaCodecPlayer::OnMediaCryptoReady, media_weak_this_);
+
+  // Post back to UI thread?
+  ui_task_runner_->PostTask(FROM_HERE,
+                            base::Bind(&MediaDrmBridge::SetMediaCryptoReadyCB,
+                                       drm_bridge_->WeakPtrForUIThread(), cb));
 }
 
 // Callbacks from Demuxer.
 
 void MediaCodecPlayer::OnDemuxerConfigsAvailable(
     const DemuxerConfigs& configs) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(1) << __FUNCTION__;
 
@@ skipping 240 matching lines @@
     DCHECK(!internal_error_cb_.is_null());
     GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
     return;
   }
 
   if (HasVideo() && !video_decoder_->HasVideoSurface()) {
     SetState(kStateWaitingForSurface);
     return;
   }
 
+  if (key_is_required_ && !key_is_added_) {
+    SetState(kStateWaitingForKey);
+    ui_task_runner_->PostTask(FROM_HERE, key_required_cb_);
+    return;
+  }
+
   SetState(kStatePlaying);
   StartPlaybackOrBrowserSeek();
 }
 
 void MediaCodecPlayer::OnPrerollDone() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   if (state_ != kStatePlaying) {
     DVLOG(1) << __FUNCTION__ << ": in state " << AsString(state_)
              << ", ignoring";
@@ skipping 93 matching lines @@
       return;
   }
 
   // DetachListener to UI thread
   ui_task_runner_->PostTask(FROM_HERE, detach_listener_cb_);
 
   if (AudioFinished() && VideoFinished())
     ui_task_runner_->PostTask(FROM_HERE, completion_cb_);
 }
 
+void MediaCodecPlayer::OnKeyRequired(DemuxerStream::Type type) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__ << " " << type;
+
+  // Request stop and restart to pick up the key.
+  key_is_required_ = true;
+
+  if (state_ == kStatePlaying) {
+    SetState(kStateStopping);
+    RequestToStopDecoders();
+    SetPendingStart(true);
+  }

[xhwang, 2015/09/30 18:07:53]

It seems to me whenever a key is required we'll stop the decoders and then
restart the playback. If a key has been added, we'll try to decode again.
Otherwise, we'll enter the kStateWaitingForKey state. Is that accurate?

I wonder if  |key_is_added_| is true here, should we try to decode again
immediately instead going through the whole stop/start process?

One tricky thing is that |key_is_added_| doesn't necessarily mean "new key is
available since last decode attempt", which is what
|key_added_while_decode_pending_| in MediaSourcePlayer mean. We have to clear
|key_is_added_| before each decode to make sure we don't end up trying again and
again for nothing...

This makes me wonder what's the cost of the extra stop/start process? If it's
minimal, maybe it's not worth the extra complexity. But if it's big, some
optimization would be nice.

[Tima Vaisburd, 2015/09/30 21:24:51]

Yes.
To answer your question below, the start/stop has been quite fast in my
experience.
Could you please elaborate on this part? I thought we could not rely on
|key_is_added_| - the same as OnKeyAdded() - because the latter might come in
the middle of a successful playback, and not necessarily in response for an
error. Is this correct?

But if the receive OnKeyAdded when we wait for the key, I though we can think
exactly as you wrote, available since last decode attempt.

Do I miss something here?
Did you mean to "avoid retrying when we need to wait"?

[xhwang, 2015/10/01 00:04:39]

In that case I think your impl is good.
Sorry for the confusion. My whole point was that previously (in
MediaSourcePlayer) if we get NO_KEY, but a key has just been added while we are
doing the decoding, we would try again immediately without stopping the
playback. So I wonder whether that's also possible in this new MediaCodecPlayer.
To do that, |key_is_added_| isn't sufficient, we need something like
|key_added_while_decode_pending_|. So my question is whether that's easy to do.
If not, I think the currently approach is acceptable, given the fact that
key_added_while_decode_pending_ should be rare, and the stop/start process is
fast.

[Tima Vaisburd, 2015/10/01 00:36:06]

It seems it would be not that hard to try again several times, but how many
times? I can imagine the decoder won't report the problem right away, but would
keep trying because it believes that the key will come "real soon". But if it
won't, then the current scenario should kick in.

The MediaSourcePlayer is strictly sequential, as far as I understand. We decode
one frame, then render, then check, then decode another frame. In this player
there is no direct intervention into decoder process.

[xhwang, 2015/10/01 00:50:05]

Try until there's no new key available. New key is a rare event and we shouldn't
really see it very often. To be clear, we'll try again when some new key has
been added while we were decoding, not when we believe that key will come.

I don't know how MediaCodecPlayer works exactly. So if this doesn't make sense
please ignore :)

+}
+
 void MediaCodecPlayer::OnError() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   // kStateError blocks all events
   SetState(kStateError);
 
   ReleaseDecoderResources();
 
   ui_task_runner_->PostTask(FROM_HERE,
@@ skipping 63 matching lines @@
 void MediaCodecPlayer::OnVideoResolutionChanged(const gfx::Size& size) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(1) << __FUNCTION__ << " " << size.width() << "x" << size.height();
 
   // Update cache and notify manager on UI thread
   ui_task_runner_->PostTask(
       FROM_HERE, base::Bind(metadata_changed_cb_, kNoTimestamp(), size));
 }
 
+// Callbacks from DRM

[xhwang, 2015/09/30 18:07:53]

s/DRM/MediaDrmBridge.

[Tima Vaisburd, 2015/09/30 23:00:50]

Done.

+
+void MediaCodecPlayer::OnMediaCryptoReady(
+    MediaDrmBridge::JavaObjectPtr media_crypto,
+    bool needs_protected_surface) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__ << " protected surface is "
+           << (needs_protected_surface ? "required" : "not required");
+
+  // We use the parameters that come with this callback every time we call
+  // Configure(). This is possible only if the MediaCrypto object remains valid
+  // and the surface requirement does not change until new SetCdm() is called.
+
+  DCHECK(media_crypto);
+  DCHECK(!media_crypto->is_null());
+
+  media_crypto_ = media_crypto.Pass();
+
+  if (audio_decoder_) {
+    audio_decoder_->SetNeedsReconfigure();
+  }
+
+  if (video_decoder_) {
+    video_decoder_->SetNeedsReconfigure();
+    video_decoder_->SetProtectedSurfaceRequired(needs_protected_surface);
+  }
+
+  if (state_ == kStateWaitingForCrypto) {
+    // Resume start sequence (configure, etc.)
+    SetState(kStatePlaying);
+    StartPlaybackOrBrowserSeek();
+  }
+
+  DVLOG(1) << __FUNCTION__ << " end";
+}
+
+void MediaCodecPlayer::OnKeyAdded() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  key_is_added_ = true;
+
+  if (state_ == kStateWaitingForKey) {
+    SetState(kStatePlaying);
+    StartPlaybackOrBrowserSeek();
+  }
+}
+
+void MediaCodecPlayer::OnCdmUnset() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  // This comment is copied from MediaSourcePlayer::OnCdmUnset().
+  // 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).
+
+  if (audio_decoder_) {
+    audio_decoder_->SetNeedsReconfigure();
+  }
+
+  if (video_decoder_) {
+    video_decoder_->SetProtectedSurfaceRequired(false);
+    video_decoder_->SetNeedsReconfigure();
+  }
+
+  cdm_registration_id_ = 0;
+  drm_bridge_ = nullptr;
+  media_crypto_.reset();
+}
+
 // 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;
 }
 
 void MediaCodecPlayer::SetPendingStart(bool need_to_start) {
@@ skipping 91 matching lines @@
     video_decoder_->Prefetch(prefetch_cb);
 }
 
 void MediaCodecPlayer::StartPlaybackOrBrowserSeek() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   // TODO(timav): consider replacing this method with posting a
   // browser seek task (i.e. generate an event) from StartPlaybackDecoders().
 
+  // Clear encryption key related flags.
+  key_is_required_ = false;
+  key_is_added_ = false;
+
   StartStatus status = StartPlaybackDecoders();
 
   switch (status) {
     case kStartBrowserSeekRequired:
       // Browser seek
       SetState(kStateWaitingForSeek);
       SetPendingStart(true);
       StopDecoders();
       RequestDemuxerSeek(GetInterpolatedTime(), true);
       break;
+    case kStartCryptoRequired:
+      SetState(kStateWaitingForCrypto);
+      break;
     case kStartFailed:
       GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
       break;
     case kStartOk:
       break;
   }
 }
 
 MediaCodecPlayer::StartStatus MediaCodecPlayer::StartPlaybackDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
@@ skipping 17 matching lines @@
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   const bool do_audio = !AudioFinished();
   const bool do_video = !VideoFinished();
 
   // If there is nothing to play, the state machine should determine this at the
   // prefetch state and never call this method.
   DCHECK(do_audio || do_video);
 
-  // Start with video: if browser seek is required it would
-  // not make sense to configure audio.
+  bool need_crypto = (do_audio && audio_decoder_->IsContentEncrypted()) ||
+                     (do_video && video_decoder_->IsContentEncrypted());
 
-  if (do_video) {
-    MediaCodecDecoder::ConfigStatus status = video_decoder_->Configure();
-    switch (status) {
-      case MediaCodecDecoder::kConfigOk:
-        break;
-      case MediaCodecDecoder::kConfigKeyFrameRequired:
-        // TODO(timav): post a task or return the status?
-        return kStartBrowserSeekRequired;
-      case MediaCodecDecoder::kConfigFailure:
-        return kStartFailed;
+  // Do we need to create a local ref from the global ref?
+  jobject media_crypto = media_crypto_ ? media_crypto_->obj() : nullptr;
+
+  if (need_crypto) {
+    DVLOG(1) << (audio_decoder_->IsContentEncrypted() ? " audio" : "")
+             << (video_decoder_->IsContentEncrypted() ? " video" : "")
+             << " need(s) encryption";
+    if (!media_crypto) {
+      DVLOG(1) << __FUNCTION__ << ": MediaCrypto is not found, returning";
+      return kStartCryptoRequired;
     }
   }
 
-  if (do_audio) {
-    MediaCodecDecoder::ConfigStatus status = audio_decoder_->Configure();
-    if (status != MediaCodecDecoder::kConfigOk) {
+  // Start with video: if browser seek is required it would not make sense to
+  // configure audio.
+
+  MediaCodecDecoder::ConfigStatus status = MediaCodecDecoder::kConfigOk;
+  if (do_video)
+    status = video_decoder_->Configure(media_crypto);
+
+  if (status == MediaCodecDecoder::kConfigOk && do_audio)
+    status = audio_decoder_->Configure(media_crypto);
+
+  switch (status) {
+    case MediaCodecDecoder::kConfigOk:
+      break;
+    case MediaCodecDecoder::kConfigKeyFrameRequired:
+      return kStartBrowserSeekRequired;
+    case MediaCodecDecoder::kConfigNoCrypto:  // TODO: delete this
+      return kStartCryptoRequired;
+    case MediaCodecDecoder::kConfigFailure:
       return kStartFailed;
-    }
   }
-
   return kStartOk;
 }
 
 MediaCodecPlayer::StartStatus MediaCodecPlayer::MaybePrerollDecoders(
     bool* preroll_required) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(1) << __FUNCTION__ << " current_time:" << GetInterpolatedTime();
 
   // If requested, preroll is always done in the beginning of the playback,
@@ skipping 138 matching lines @@
 
   audio_decoder_.reset(new MediaCodecAudioDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
                  DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
                  DemuxerStream::AUDIO),
+      base::Bind(&MediaCodecPlayer::OnKeyRequired, media_weak_this_,
+                 DemuxerStream::AUDIO),
       internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::AUDIO)));
 
   video_decoder_.reset(new MediaCodecVideoDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
                  DemuxerStream::VIDEO),
+      base::Bind(&MediaCodecPlayer::OnKeyRequired, media_weak_this_,
+                 DemuxerStream::VIDEO),
       internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnVideoResolutionChanged, media_weak_this_),
       base::Bind(&MediaCodecPlayer::OnVideoCodecCreated, media_weak_this_)));
 }
 
 bool MediaCodecPlayer::AudioFinished() const {
   return audio_decoder_->IsCompleted() || !audio_decoder_->HasStream();
 }
@@ skipping 16 matching lines @@
 
 const char* MediaCodecPlayer::AsString(PlayerState state) {
   switch (state) {
     RETURN_STRING(kStatePaused);
     RETURN_STRING(kStateWaitingForConfig);
     RETURN_STRING(kStateWaitingForPermission);
     RETURN_STRING(kStatePrefetching);
     RETURN_STRING(kStatePlaying);
     RETURN_STRING(kStateStopping);
     RETURN_STRING(kStateWaitingForSurface);
+    RETURN_STRING(kStateWaitingForKey);
+    RETURN_STRING(kStateWaitingForCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media