Generalize Pepper CDM API decrypt and decode.

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 360 matching lines @@
   // PPB_ContentDecryptor_Private interface.
   virtual void GenerateKeyRequest(const std::string& key_system,
                                   pp::VarArrayBuffer init_data) OVERRIDE;
   virtual void AddKey(const std::string& session_id,
                       pp::VarArrayBuffer key,
                       pp::VarArrayBuffer init_data) OVERRIDE;
   virtual void CancelKeyRequest(const std::string& session_id) OVERRIDE;
   virtual void Decrypt(
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
-  virtual void DecryptAndDecodeFrame(
+  virtual void DecryptAndDecode(
       pp::Buffer_Dev encrypted_frame,
-      const PP_EncryptedVideoFrameInfo& encrypted_video_frame_info) OVERRIDE;
+      const PP_EncryptedMediaInfo& encrypted_media_info) OVERRIDE;
 
  private:
   typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
   typedef linked_ptr<KeyMessageImpl> LinkedKeyMessage;
   typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
 
   // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
   // <code>callback_factory_</code> to ensure that calls into
   // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
   void KeyAdded(int32_t result, const std::string& session_id);
@@ skipping 129 matching lines @@
   LinkedDecryptedBlock decrypted_block(new DecryptedBlockImpl());
   cdm::Status status = cdm_->Decrypt(input_buffer, decrypted_block.get());
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DeliverBlock,
       status,
       decrypted_block,
       encrypted_block_info.tracking_info));
 }
 
-void CdmWrapper::DecryptAndDecodeFrame(
+void CdmWrapper::DecryptAndDecode(
     pp::Buffer_Dev encrypted_frame,
-    const PP_EncryptedVideoFrameInfo& encrypted_video_frame_info) {
+    const PP_EncryptedMediaInfo& encrypted_media_info) {
   PP_DCHECK(!encrypted_frame.is_null());
   PP_DCHECK(cdm_);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   ConfigureInputBuffer(encrypted_frame,
-                       encrypted_video_frame_info.encryption_info,
+                       encrypted_media_info.encryption_info,
                        &subsamples,
                        &input_buffer);
 
+  // TODO(tomfinegan): Remove this check when audio decoding is added.
+  if (encrypted_media_info.media_type == PP_STREAMTYPE_VIDEO) {

[Ami GONE FROM CHROMIUM, 2012/10/10 07:30:26]

s/VIDEO/AUDIO/
but actually see below

[Tom Finegan, 2012/10/10 08:26:06]

Done.

+    PP_DCHECK(false);

[Ami GONE FROM CHROMIUM, 2012/10/10 07:30:26]

DCHECKs shouldn't be handled.
I'd replace l547-550 with:
PP_DCHECK(encrypted_media_info.media_type == PP_STREAMTYPE_VIDEO);

[Tom Finegan, 2012/10/10 08:26:06]

Done.

+    return;
+  }
+
   LinkedVideoFrame video_frame(new VideoFrameImpl());
   cdm::Status status = cdm_->DecryptAndDecodeFrame(input_buffer,
-                                                   video_frame.get());
+                                                    video_frame.get());
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DeliverFrame,
       status,
       video_frame,
-      encrypted_video_frame_info.encryption_info.tracking_info));
+      encrypted_media_info.encryption_info.tracking_info));
 }
 
 void CdmWrapper::KeyAdded(int32_t result, const std::string& session_id) {
   pp::ContentDecryptor_Private::KeyAdded(key_system_, session_id);
 }
 
 void CdmWrapper::KeyMessage(int32_t result,
                             const LinkedKeyMessage& key_message) {
   pp::Buffer_Dev message_buffer =
       static_cast<const PpbBuffer*>(key_message->message())->buffer_dev();
@@ skipping 41 matching lines @@
           pp::Buffer_Dev();
 
   pp::ContentDecryptor_Private::DeliverBlock(buffer, decrypted_block_info);
 }
 
 void CdmWrapper::DeliverFrame(
     int32_t result,
     const cdm::Status& status,
     const LinkedVideoFrame& video_frame,
     const PP_DecryptTrackingInfo& tracking_info) {
+  PP_DCHECK(result == PP_OK);
   PP_DecryptedFrameInfo decrypted_frame_info;
   decrypted_frame_info.tracking_info = tracking_info;
 
   switch (status) {
     case cdm::kSuccess:
       PP_DCHECK(video_frame->format() == cdm::kI420 ||
                 video_frame->format() == cdm::kYv12);
       PP_DCHECK(video_frame.get() && video_frame->frame_buffer());
       decrypted_frame_info.result = PP_DECRYPTRESULT_SUCCESS;
       decrypted_frame_info.format =
@@ skipping 50 matching lines @@
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::CdmWrapperModule();
 }
 
 }  // namespace pp