Update PluginInstance for audio support for content decryption.

webkit/media/crypto/ppapi/cdm_wrapper.cc

 // Copyright (c) 2012 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 <cstring>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 458 matching lines @@
   void DecoderDeinitializeDone(int32_t result,
                                PP_DecryptorStreamType decoder_type,
                                uint32_t request_id);
   void DecoderResetDone(int32_t result,
                         PP_DecryptorStreamType decoder_type,
                         uint32_t request_id);
   void DeliverFrame(int32_t result,
                     const cdm::Status& status,
                     const LinkedVideoFrame& video_frame,
                     const PP_DecryptTrackingInfo& tracking_info);
+  void DeliverSamples(int32_t result,
+                      const cdm::Status& status,
+                      const LinkedDecryptedBlock& audio_frames,

[ddorwin, 2012/10/22 17:47:11]

Type should be Samples/AudioFrames?
It sounds like DecryptedBlock has a timestamp we don't need. What is the
downside of having a separate type without it?

[xhwang, 2012/10/23 01:53:12]

Added AudioFrame class. But we need a ppapi change for this. So in ppapi I am
still using PP_DecryptedBlockInfo. Added a TODO for that.

+                      const PP_DecryptTrackingInfo& tracking_info);
 
   // Helper for SetTimer().
   void TimerExpired(int32 result);
 
   PpbBufferAllocator allocator_;
   pp::CompletionCallbackFactory<CdmWrapper> callback_factory_;
   cdm::ContentDecryptionModule* cdm_;
   std::string key_system_;
 };
 
@@ skipping 182 matching lines @@
   // here.
   CallOnMain(callback_factory_.NewCallback(&CdmWrapper::DecoderResetDone,
                                            decoder_type,
                                            request_id));
 }
 
 void CdmWrapper::DecryptAndDecode(
     PP_DecryptorStreamType decoder_type,
     pp::Buffer_Dev encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info) {
-  // TODO(tomfinegan): Remove this check when audio decoding is added.
-  PP_DCHECK(decoder_type == PP_DECRYPTORSTREAMTYPE_VIDEO);
   PP_DCHECK(cdm_);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   if (!encrypted_buffer.is_null()) {
     ConfigureInputBuffer(encrypted_buffer,
                          encrypted_block_info,
                          &subsamples,
                          &input_buffer);
   }
 
-  LinkedVideoFrame video_frame(new VideoFrameImpl());
-  cdm::Status status = cdm_->DecryptAndDecodeFrame(input_buffer,
-                                                   video_frame.get());
-  CallOnMain(callback_factory_.NewCallback(
-      &CdmWrapper::DeliverFrame,
-      status,
-      video_frame,
-      encrypted_block_info.tracking_info));
+  if (decoder_type == PP_DECRYPTORSTREAMTYPE_AUDIO) {

[ddorwin, 2012/10/22 17:47:11]

We should check for an invalid value somewhere. I like switch statements for
ensuring all enums are handled (not sure if that build switch is set). 

[xhwang, 2012/10/23 01:53:12]

Done.

+    LinkedDecryptedBlock audio_frames(new DecryptedBlockImpl());
+    cdm::Status status = cdm_->DecryptAndDecodeSamples(input_buffer,
+                                                       audio_frames.get());
+    CallOnMain(callback_factory_.NewCallback(
+        &CdmWrapper::DeliverSamples,
+        status,
+        audio_frames,
+        encrypted_block_info.tracking_info));
+  } else {  // decoder_type == PP_DECRYPTORSTREAMTYPE_VIDEO
+    LinkedVideoFrame video_frame(new VideoFrameImpl());
+    cdm::Status status = cdm_->DecryptAndDecodeFrame(input_buffer,
+                                                     video_frame.get());
+    CallOnMain(callback_factory_.NewCallback(
+        &CdmWrapper::DeliverFrame,
+        status,
+        video_frame,
+        encrypted_block_info.tracking_info));
+  }
 }
 
 void CdmWrapper::SetTimer(int64 delay_ms) {
   // NOTE: doesn't really need to run on the main thread; could just as well run
   // on a helper thread if |cdm_| were thread-friendly and care was taken.  We
   // only use CallOnMainThread() here to get delayed-execution behavior.
   pp::Module::Get()->core()->CallOnMainThread(
       delay_ms,
       callback_factory_.NewCallback(&CdmWrapper::TimerExpired),
       PP_OK);
@@ skipping 156 matching lines @@
   }
 
   const pp::Buffer_Dev& buffer =
       video_frame.get() && video_frame->frame_buffer() ?
           static_cast<PpbBuffer*>(video_frame->frame_buffer())->buffer_dev() :
           pp::Buffer_Dev();
 
   pp::ContentDecryptor_Private::DeliverFrame(buffer, decrypted_frame_info);
 }
 
+void CdmWrapper::DeliverSamples(int32_t result,
+                                const cdm::Status& status,
+                                const LinkedDecryptedBlock& audio_frames,
+                                const PP_DecryptTrackingInfo& tracking_info) {
+  PP_DCHECK(result == PP_OK);
+  PP_DecryptedBlockInfo decrypted_block_info;
+  decrypted_block_info.tracking_info = tracking_info;
+  decrypted_block_info.tracking_info.timestamp = audio_frames->timestamp();

[ddorwin, 2012/10/22 17:47:11]

What is this timestamp? Do we need it? We should probably at least comment that
is is the original timestamp.

[xhwang, 2012/10/23 01:53:12]

Done.

+
+  switch (status) {
+    case cdm::kSuccess:
+      decrypted_block_info.result = PP_DECRYPTRESULT_SUCCESS;
+      PP_DCHECK(audio_frames.get() && audio_frames->buffer());
+      break;
+    case cdm::kNeedMoreData:
+      decrypted_block_info.result = PP_DECRYPTRESULT_SUCCESS;
+      break;
+    case cdm::kNoKey:
+      decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_NOKEY;
+      break;
+    case cdm::kDecryptError:
+      decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
+      break;
+    default:
+      PP_DCHECK(false);
+      decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
+  }
+
+  const pp::Buffer_Dev& buffer =
+      audio_frames.get() && audio_frames->buffer() ?
+      static_cast<PpbBuffer*>(audio_frames->buffer())->buffer_dev() :
+          pp::Buffer_Dev();
+
+  pp::ContentDecryptor_Private::DeliverSamples(buffer, decrypted_block_info);
+}
+
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class CdmWrapperModule : public pp::Module {
  public:
   CdmWrapperModule() : pp::Module() {}
   virtual ~CdmWrapperModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new CdmWrapper(instance, this);
   }
 };
 
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::CdmWrapperModule();
 }
 
 }  // namespace pp