Add TrackableCallback in ContentDecryptorDelegate.

content/renderer/pepper/content_decryptor_delegate.cc

Index: content/renderer/pepper/content_decryptor_delegate.cc
diff --git a/content/renderer/pepper/content_decryptor_delegate.cc b/content/renderer/pepper/content_decryptor_delegate.cc
index 49790db2b7b8b15ab993a79297f7cb338e56bbf4..6712f46074dbef238461e1b70729cfa93d8a090b 100644
--- a/content/renderer/pepper/content_decryptor_delegate.cc
+++ b/content/renderer/pepper/content_decryptor_delegate.cc
@@ -26,6 +26,7 @@
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "ui/gfx/rect.h"
 
+using media::Decryptor;
 using ppapi::ArrayBufferVar;
 using ppapi::PpapiGlobals;
 using ppapi::ScopedPPResource;
@@ -186,31 +187,31 @@ PP_DecryptedFrameFormat MediaVideoFormatToPpDecryptedFrameFormat(
   }
 }
 
-media::Decryptor::Status PpDecryptResultToMediaDecryptorStatus(
+Decryptor::Status PpDecryptResultToMediaDecryptorStatus(
     PP_DecryptResult result) {
   switch (result) {
     case PP_DECRYPTRESULT_SUCCESS:
-      return media::Decryptor::kSuccess;
+      return Decryptor::kSuccess;
     case PP_DECRYPTRESULT_DECRYPT_NOKEY:
-      return media::Decryptor::kNoKey;
+      return Decryptor::kNoKey;
     case PP_DECRYPTRESULT_NEEDMOREDATA:
-      return media::Decryptor::kNeedMoreData;
+      return Decryptor::kNeedMoreData;
     case PP_DECRYPTRESULT_DECRYPT_ERROR:
-      return media::Decryptor::kError;
+      return Decryptor::kError;
     case PP_DECRYPTRESULT_DECODE_ERROR:
-      return media::Decryptor::kError;
+      return Decryptor::kError;
     default:
       NOTREACHED();
-      return media::Decryptor::kError;
+      return Decryptor::kError;
   }
 }
 
 PP_DecryptorStreamType MediaDecryptorStreamTypeToPpStreamType(
-    media::Decryptor::StreamType stream_type) {
+    Decryptor::StreamType stream_type) {
   switch (stream_type) {
-    case media::Decryptor::kAudio:
+    case Decryptor::kAudio:
       return PP_DECRYPTORSTREAMTYPE_AUDIO;
-    case media::Decryptor::kVideo:
+    case Decryptor::kVideo:
       return PP_DECRYPTORSTREAMTYPE_VIDEO;
     default:
       NOTREACHED();
@@ -247,12 +248,6 @@ ContentDecryptorDelegate::ContentDecryptorDelegate(
     : pp_instance_(pp_instance),
       plugin_decryption_interface_(plugin_decryption_interface),
       next_decryption_request_id_(1),
-      pending_audio_decrypt_request_id_(0),
-      pending_video_decrypt_request_id_(0),
-      pending_audio_decoder_init_request_id_(0),
-      pending_video_decoder_init_request_id_(0),
-      pending_audio_decode_request_id_(0),
-      pending_video_decode_request_id_(0),
       audio_samples_per_second_(0),
       audio_channel_count_(0),
       weak_ptr_factory_(this) {
@@ -319,9 +314,9 @@ bool ContentDecryptorDelegate::ReleaseSession(uint32 session_id) {
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
-    media::Decryptor::StreamType stream_type,
+    Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
-    const media::Decryptor::DecryptCB& decrypt_cb) {
+    const Decryptor::DecryptCB& decrypt_cb) {
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
   // |{audio|video}_input_resource_| is not being used by the plugin
   // now because there is only one pending audio/video decrypt request at any
@@ -346,17 +341,11 @@ bool ContentDecryptorDelegate::Decrypt(
   // There is only one pending decrypt request at any time per stream. This is
   // enforced by the media pipeline.
   switch (stream_type) {
-    case media::Decryptor::kAudio:
-      DCHECK_EQ(pending_audio_decrypt_request_id_, 0u);
-      DCHECK(pending_audio_decrypt_cb_.is_null());
-      pending_audio_decrypt_request_id_ = request_id;
-      pending_audio_decrypt_cb_ = decrypt_cb;
+    case Decryptor::kAudio:
+      audio_decrypt_cb_.Set(request_id, decrypt_cb);
       break;
-    case media::Decryptor::kVideo:
-      DCHECK_EQ(pending_video_decrypt_request_id_, 0u);
-      DCHECK(pending_video_decrypt_cb_.is_null());
-      pending_video_decrypt_request_id_ = request_id;
-      pending_video_decrypt_cb_ = decrypt_cb;
+    case Decryptor::kVideo:
+      video_decrypt_cb_.Set(request_id, decrypt_cb);
       break;
     default:
       NOTREACHED();
@@ -372,26 +361,24 @@ bool ContentDecryptorDelegate::Decrypt(
 }
 
 bool ContentDecryptorDelegate::CancelDecrypt(
-    media::Decryptor::StreamType stream_type) {
+    Decryptor::StreamType stream_type) {
   DVLOG(3) << "CancelDecrypt() - stream_type: " << stream_type;
 
-  media::Decryptor::DecryptCB decrypt_cb;
+  Decryptor::DecryptCB decrypt_cb;
   switch (stream_type) {
-    case media::Decryptor::kAudio:
+    case Decryptor::kAudio:
       // Release the shared memory as it can still be in use by the plugin.
       // The next Decrypt() call will need to allocate a new shared memory
       // buffer.
       audio_input_resource_ = NULL;
-      pending_audio_decrypt_request_id_ = 0;
-      decrypt_cb = base::ResetAndReturn(&pending_audio_decrypt_cb_);
+      decrypt_cb = audio_decrypt_cb_.ResetAndReturn();
       break;
-    case media::Decryptor::kVideo:
+    case Decryptor::kVideo:
       // Release the shared memory as it can still be in use by the plugin.
       // The next Decrypt() call will need to allocate a new shared memory
       // buffer.
       video_input_resource_ = NULL;
-      pending_video_decrypt_request_id_ = 0;
-      decrypt_cb = base::ResetAndReturn(&pending_video_decrypt_cb_);
+      decrypt_cb = video_decrypt_cb_.ResetAndReturn();
       break;
     default:
       NOTREACHED();
@@ -399,14 +386,14 @@ bool ContentDecryptorDelegate::CancelDecrypt(
   }
 
   if (!decrypt_cb.is_null())
-    decrypt_cb.Run(media::Decryptor::kSuccess, NULL);
+    decrypt_cb.Run(Decryptor::kSuccess, NULL);
 
   return true;
 }
 
 bool ContentDecryptorDelegate::InitializeAudioDecoder(
     const media::AudioDecoderConfig& decoder_config,
-    const media::Decryptor::DecoderInitCB& init_cb) {
+    const Decryptor::DecoderInitCB& init_cb) {
   PP_AudioDecoderConfig pp_decoder_config;
   pp_decoder_config.codec =
       MediaAudioCodecToPpAudioCodec(decoder_config.codec());
@@ -428,11 +415,7 @@ bool ContentDecryptorDelegate::InitializeAudioDecoder(
   }
   ScopedPPResource pp_resource(extra_data_resource.get());
 
-  DCHECK_EQ(pending_audio_decoder_init_request_id_, 0u);
-  DCHECK(pending_audio_decoder_init_cb_.is_null());
-  pending_audio_decoder_init_request_id_ = pp_decoder_config.request_id;
-  pending_audio_decoder_init_cb_ = init_cb;
-
+  audio_decoder_init_cb_.Set(pp_decoder_config.request_id, init_cb);
   plugin_decryption_interface_->InitializeAudioDecoder(pp_instance_,
                                                        &pp_decoder_config,
                                                        pp_resource);
@@ -441,7 +424,7 @@ bool ContentDecryptorDelegate::InitializeAudioDecoder(
 
 bool ContentDecryptorDelegate::InitializeVideoDecoder(
     const media::VideoDecoderConfig& decoder_config,
-    const media::Decryptor::DecoderInitCB& init_cb) {
+    const Decryptor::DecoderInitCB& init_cb) {
   PP_VideoDecoderConfig pp_decoder_config;
   pp_decoder_config.codec =
       MediaVideoCodecToPpVideoCodec(decoder_config.codec());
@@ -462,11 +445,7 @@ bool ContentDecryptorDelegate::InitializeVideoDecoder(
   }
   ScopedPPResource pp_resource(extra_data_resource.get());
 
-  DCHECK_EQ(pending_video_decoder_init_request_id_, 0u);
-  DCHECK(pending_video_decoder_init_cb_.is_null());
-  pending_video_decoder_init_request_id_ = pp_decoder_config.request_id;
-  pending_video_decoder_init_cb_ = init_cb;
-
+  video_decoder_init_cb_.Set(pp_decoder_config.request_id, init_cb);
   natural_size_ = decoder_config.natural_size();
 
   plugin_decryption_interface_->InitializeVideoDecoder(pp_instance_,
@@ -476,7 +455,7 @@ bool ContentDecryptorDelegate::InitializeVideoDecoder(
 }
 
 bool ContentDecryptorDelegate::DeinitializeDecoder(
-    media::Decryptor::StreamType stream_type) {
+    Decryptor::StreamType stream_type) {
   CancelDecode(stream_type);
 
   natural_size_ = gfx::Size();
@@ -488,8 +467,7 @@ bool ContentDecryptorDelegate::DeinitializeDecoder(
   return true;
 }
 
-bool ContentDecryptorDelegate::ResetDecoder(
-    media::Decryptor::StreamType stream_type) {
+bool ContentDecryptorDelegate::ResetDecoder(Decryptor::StreamType stream_type) {
   CancelDecode(stream_type);
 
   // TODO(tomfinegan): Add decoder reset request tracking.
@@ -500,14 +478,13 @@ bool ContentDecryptorDelegate::ResetDecoder(
 
 bool ContentDecryptorDelegate::DecryptAndDecodeAudio(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
-    const media::Decryptor::AudioDecodeCB& audio_decode_cb) {
+    const Decryptor::AudioDecodeCB& audio_decode_cb) {
   // |audio_input_resource_| is not being used by the plugin now
   // because there is only one pending audio decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
-  if (!MakeMediaBufferResource(media::Decryptor::kAudio,
-                               encrypted_buffer,
-                               &encrypted_resource)) {
+  if (!MakeMediaBufferResource(
+           Decryptor::kAudio, encrypted_buffer, &encrypted_resource)) {
     return false;
   }
 
@@ -529,10 +506,7 @@ bool ContentDecryptorDelegate::DecryptAndDecodeAudio(
   // enforced by the media pipeline. If this DCHECK is violated, our buffer
   // reuse policy is not valid, and we may have race problems for the shared
   // buffer.
-  DCHECK_EQ(pending_audio_decode_request_id_, 0u);
-  DCHECK(pending_audio_decode_cb_.is_null());
-  pending_audio_decode_request_id_ = request_id;
-  pending_audio_decode_cb_ = audio_decode_cb;
+  audio_decode_cb_.Set(request_id, audio_decode_cb);
 
   ScopedPPResource pp_resource(encrypted_resource.get());
   plugin_decryption_interface_->DecryptAndDecode(pp_instance_,
@@ -544,14 +518,13 @@ bool ContentDecryptorDelegate::DecryptAndDecodeAudio(
 
 bool ContentDecryptorDelegate::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
-    const media::Decryptor::VideoDecodeCB& video_decode_cb) {
+    const Decryptor::VideoDecodeCB& video_decode_cb) {
   // |video_input_resource_| is not being used by the plugin now
   // because there is only one pending video decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
-  if (!MakeMediaBufferResource(media::Decryptor::kVideo,
-                               encrypted_buffer,
-                               &encrypted_resource)) {
+  if (!MakeMediaBufferResource(
+           Decryptor::kVideo, encrypted_buffer, &encrypted_resource)) {

[dmichael (off chromium), 2014/01/03 18:44:43]

style nit: I would probably put the first two parameters on line 526, assuming
they fit.

But this might be just my taste. If you're using the clang formatter, definitely
ignore this comment. I'm not used to its quirks yet.

[xhwang, 2014/01/07 22:40:21]

Yeah, this is done by clang-format. Personally I won't write code like this
either :)

     return false;
   }
 
@@ -575,10 +548,7 @@ bool ContentDecryptorDelegate::DecryptAndDecodeVideo(
   // media pipeline. If this DCHECK is violated, our buffer
   // reuse policy is not valid, and we may have race problems for the shared
   // buffer.
-  DCHECK_EQ(pending_video_decode_request_id_, 0u);
-  DCHECK(pending_video_decode_cb_.is_null());
-  pending_video_decode_request_id_ = request_id;
-  pending_video_decode_cb_ = video_decode_cb;
+  video_decode_cb_.Set(request_id, video_decode_cb);
 
   // TODO(tomfinegan): Need to get stream type from media stack.
   ScopedPPResource pp_resource(encrypted_resource.get());
@@ -660,26 +630,18 @@ void ContentDecryptorDelegate::DecoderInitializeDone(
   if (decoder_type == PP_DECRYPTORSTREAMTYPE_AUDIO) {
     // If the request ID is not valid or does not match what's saved, do
     // nothing.
-    if (request_id == 0 ||
-        request_id != pending_audio_decoder_init_request_id_)
+    if (request_id == 0 || !audio_decoder_init_cb_.Matches(request_id))
       return;
 
-      DCHECK(!pending_audio_decoder_init_cb_.is_null());
-      pending_audio_decoder_init_request_id_ = 0;
-      base::ResetAndReturn(
-          &pending_audio_decoder_init_cb_).Run(PP_ToBool(success));
+    audio_decoder_init_cb_.ResetAndReturn().Run(PP_ToBool(success));
   } else {
-    if (request_id == 0 ||
-        request_id != pending_video_decoder_init_request_id_)
+    if (request_id == 0 || !video_decoder_init_cb_.Matches(request_id))
       return;
 
-      if (!success)
-        natural_size_ = gfx::Size();
+    if (!success)
+      natural_size_ = gfx::Size();
 
-      DCHECK(!pending_video_decoder_init_cb_.is_null());
-      pending_video_decoder_init_request_id_ = 0;
-      base::ResetAndReturn(
-          &pending_video_decoder_init_cb_).Run(PP_ToBool(success));
+    video_decoder_init_cb_.ResetAndReturn().Run(PP_ToBool(success));
   }
 }
 
@@ -711,36 +673,32 @@ void ContentDecryptorDelegate::DeliverBlock(
     return;
   }
 
-  media::Decryptor::DecryptCB decrypt_cb;
-  if (request_id == pending_audio_decrypt_request_id_) {
-    DCHECK(!pending_audio_decrypt_cb_.is_null());
-    pending_audio_decrypt_request_id_ = 0;
-    decrypt_cb = base::ResetAndReturn(&pending_audio_decrypt_cb_);
-  } else if (request_id == pending_video_decrypt_request_id_) {
-    DCHECK(!pending_video_decrypt_cb_.is_null());
-    pending_video_decrypt_request_id_ = 0;
-    decrypt_cb = base::ResetAndReturn(&pending_video_decrypt_cb_);
+  Decryptor::DecryptCB decrypt_cb;
+  if (audio_decrypt_cb_.Matches(request_id)) {
+    decrypt_cb = audio_decrypt_cb_.ResetAndReturn();
+  } else if (video_decrypt_cb_.Matches(request_id)) {
+    decrypt_cb = video_decrypt_cb_.ResetAndReturn();
   } else {
     DVLOG(1) << "DeliverBlock() - request_id " << request_id << " not found";
     return;
   }
 
-  media::Decryptor::Status status =
+  Decryptor::Status status =
       PpDecryptResultToMediaDecryptorStatus(block_info->result);
-  if (status != media::Decryptor::kSuccess) {
+  if (status != Decryptor::kSuccess) {
     decrypt_cb.Run(status, NULL);
     return;
   }
 
   EnterResourceNoLock<PPB_Buffer_API> enter(decrypted_block, true);
   if (!enter.succeeded()) {
-    decrypt_cb.Run(media::Decryptor::kError, NULL);
+    decrypt_cb.Run(Decryptor::kError, NULL);
     return;
   }
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size() ||
       mapper.size() < block_info->data_size) {
-    decrypt_cb.Run(media::Decryptor::kError, NULL);
+    decrypt_cb.Run(Decryptor::kError, NULL);
     return;
   }
 
@@ -751,7 +709,7 @@ void ContentDecryptorDelegate::DeliverBlock(
           static_cast<uint8*>(mapper.data()), block_info->data_size));
   decrypted_buffer->set_timestamp(base::TimeDelta::FromMicroseconds(
       block_info->tracking_info.timestamp));
-  decrypt_cb.Run(media::Decryptor::kSuccess, decrypted_buffer);
+  decrypt_cb.Run(Decryptor::kSuccess, decrypted_buffer);
 }
 
 // Use a non-class-member function here so that if for some reason
@@ -796,7 +754,7 @@ void ContentDecryptorDelegate::DeliverFrame(
   DVLOG(2) << "DeliverFrame() - request_id: " << request_id;
 
   // If the request ID is not valid or does not match what's saved, do nothing.
-  if (request_id == 0 || request_id != pending_video_decode_request_id_) {
+  if (request_id == 0 || !video_decode_cb_.Matches(request_id)) {
     DVLOG(1) << "DeliverFrame() - request_id " << request_id << " not found";
     FreeBuffer(frame_info->tracking_info.buffer_id);
     return;
@@ -805,14 +763,11 @@ void ContentDecryptorDelegate::DeliverFrame(
   TRACE_EVENT_ASYNC_END0(
       "media", "ContentDecryptorDelegate::DecryptAndDecodeVideo", request_id);
 
-  DCHECK(!pending_video_decode_cb_.is_null());
-  pending_video_decode_request_id_ = 0;
-  media::Decryptor::VideoDecodeCB video_decode_cb =
-      base::ResetAndReturn(&pending_video_decode_cb_);
+  Decryptor::VideoDecodeCB video_decode_cb = video_decode_cb_.ResetAndReturn();
 
-  media::Decryptor::Status status =
+  Decryptor::Status status =
       PpDecryptResultToMediaDecryptorStatus(frame_info->result);
-  if (status != media::Decryptor::kSuccess) {
+  if (status != Decryptor::kSuccess) {
     DCHECK(!frame_info->tracking_info.buffer_id);
     video_decode_cb.Run(status, NULL);
     return;
@@ -822,7 +777,7 @@ void ContentDecryptorDelegate::DeliverFrame(
   uint8* frame_data = GetMappedBuffer(decrypted_frame, &ppb_buffer);
   if (!frame_data) {
     FreeBuffer(frame_info->tracking_info.buffer_id);
-    video_decode_cb.Run(media::Decryptor::kError, NULL);
+    video_decode_cb.Run(Decryptor::kError, NULL);
     return;
   }
 
@@ -851,7 +806,7 @@ void ContentDecryptorDelegate::DeliverFrame(
                                     weak_this_,
                                     frame_info->tracking_info.buffer_id))));
 
-  video_decode_cb.Run(media::Decryptor::kSuccess, decoded_frame);
+  video_decode_cb.Run(Decryptor::kSuccess, decoded_frame);
 }
 
 void ContentDecryptorDelegate::DeliverSamples(
@@ -865,21 +820,18 @@ void ContentDecryptorDelegate::DeliverSamples(
   DVLOG(2) << "DeliverSamples() - request_id: " << request_id;
 
   // If the request ID is not valid or does not match what's saved, do nothing.
-  if (request_id == 0 || request_id != pending_audio_decode_request_id_) {
+  if (request_id == 0 || !audio_decode_cb_.Matches(request_id)) {
     DVLOG(1) << "DeliverSamples() - request_id " << request_id << " not found";
     return;
   }
 
-  DCHECK(!pending_audio_decode_cb_.is_null());
-  pending_audio_decode_request_id_ = 0;
-  media::Decryptor::AudioDecodeCB audio_decode_cb =
-      base::ResetAndReturn(&pending_audio_decode_cb_);
+  Decryptor::AudioDecodeCB audio_decode_cb = audio_decode_cb_.ResetAndReturn();
 
-  const media::Decryptor::AudioBuffers empty_frames;
+  const Decryptor::AudioBuffers empty_frames;
 
-  media::Decryptor::Status status =
+  Decryptor::Status status =
       PpDecryptResultToMediaDecryptorStatus(sample_info->result);
-  if (status != media::Decryptor::kSuccess) {
+  if (status != Decryptor::kSuccess) {
     audio_decode_cb.Run(status, empty_frames);
     return;
   }
@@ -887,42 +839,38 @@ void ContentDecryptorDelegate::DeliverSamples(
   media::SampleFormat sample_format =
       PpDecryptedSampleFormatToMediaSampleFormat(sample_info->format);
 
-  media::Decryptor::AudioBuffers audio_frame_list;
+  Decryptor::AudioBuffers audio_frame_list;
   if (!DeserializeAudioFrames(audio_frames,
                               sample_info->data_size,
                               sample_format,
                               &audio_frame_list)) {
     NOTREACHED() << "CDM did not serialize the buffer correctly.";
-    audio_decode_cb.Run(media::Decryptor::kError, empty_frames);
+    audio_decode_cb.Run(Decryptor::kError, empty_frames);
     return;
   }
 
-  audio_decode_cb.Run(media::Decryptor::kSuccess, audio_frame_list);
+  audio_decode_cb.Run(Decryptor::kSuccess, audio_frame_list);
 }
 
 // TODO(xhwang): Try to remove duplicate logic here and in CancelDecrypt().
-void ContentDecryptorDelegate::CancelDecode(
-    media::Decryptor::StreamType stream_type) {
+void ContentDecryptorDelegate::CancelDecode(Decryptor::StreamType stream_type) {
   switch (stream_type) {
-    case media::Decryptor::kAudio:
+    case Decryptor::kAudio:
       // Release the shared memory as it can still be in use by the plugin.
       // The next DecryptAndDecode() call will need to allocate a new shared
       // memory buffer.
       audio_input_resource_ = NULL;
-      pending_audio_decode_request_id_ = 0;
-      if (!pending_audio_decode_cb_.is_null())
-        base::ResetAndReturn(&pending_audio_decode_cb_).Run(
-            media::Decryptor::kSuccess, media::Decryptor::AudioBuffers());
+      if (!audio_decode_cb_.is_null())
+        audio_decode_cb_.ResetAndReturn().Run(Decryptor::kSuccess,
+                                              Decryptor::AudioBuffers());
       break;
-    case media::Decryptor::kVideo:
+    case Decryptor::kVideo:
       // Release the shared memory as it can still be in use by the plugin.
       // The next DecryptAndDecode() call will need to allocate a new shared
       // memory buffer.
       video_input_resource_ = NULL;
-      pending_video_decode_request_id_ = 0;
-      if (!pending_video_decode_cb_.is_null())
-        base::ResetAndReturn(&pending_video_decode_cb_).Run(
-            media::Decryptor::kSuccess, NULL);
+      if (!video_decode_cb_.is_null())
+        video_decode_cb_.ResetAndReturn().Run(Decryptor::kSuccess, NULL);
       break;
     default:
       NOTREACHED();
@@ -930,7 +878,7 @@ void ContentDecryptorDelegate::CancelDecode(
 }
 
 bool ContentDecryptorDelegate::MakeMediaBufferResource(
-    media::Decryptor::StreamType stream_type,
+    Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     scoped_refptr<PPB_Buffer_Impl>* resource) {
   TRACE_EVENT0("media", "ContentDecryptorDelegate::MakeMediaBufferResource");
@@ -941,11 +889,10 @@ bool ContentDecryptorDelegate::MakeMediaBufferResource(
     return true;
   }
 
-  DCHECK(stream_type == media::Decryptor::kAudio ||
-         stream_type == media::Decryptor::kVideo);
+  DCHECK(stream_type == Decryptor::kAudio || stream_type == Decryptor::kVideo);
   scoped_refptr<PPB_Buffer_Impl>& media_resource =
-      (stream_type == media::Decryptor::kAudio) ? audio_input_resource_ :
-                                                  video_input_resource_;
+      (stream_type == Decryptor::kAudio) ? audio_input_resource_
+                                         : video_input_resource_;
 
   const size_t data_size = static_cast<size_t>(encrypted_buffer->data_size());
   if (!media_resource.get() || media_resource->size() < data_size) {
@@ -964,7 +911,7 @@ bool ContentDecryptorDelegate::MakeMediaBufferResource(
       media_resource_size *= 2;
 
     DVLOG(2) << "Size of media buffer for "
-             << ((stream_type == media::Decryptor::kAudio) ? "audio" : "video")
+             << ((stream_type == Decryptor::kAudio) ? "audio" : "video")
              << " stream bumped to " << media_resource_size
              << " bytes to fit input.";
     media_resource = PPB_Buffer_Impl::CreateResource(pp_instance_,
@@ -1004,7 +951,7 @@ bool ContentDecryptorDelegate::DeserializeAudioFrames(
     PP_Resource audio_frames,
     size_t data_size,
     media::SampleFormat sample_format,
-    media::Decryptor::AudioBuffers* frames) {
+    Decryptor::AudioBuffers* frames) {
   DCHECK(frames);
   EnterResourceNoLock<PPB_Buffer_API> enter(audio_frames, true);
   if (!enter.succeeded())