Add decoder de-initialize and reset to the Pepper CDM API.

ppapi/cpp/private/content_decryptor_private.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 "ppapi/cpp/private/content_decryptor_private.h"
 
 #include <cstring>  // memcpy
 
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/private/ppb_content_decryptor_private.h"
@@ skipping 87 matching lines @@
   if (!object)
     return;
 
   pp::Buffer_Dev encrypted_block(pp::PassRef(), encrypted_resource);
 
   static_cast<ContentDecryptor_Private*>(object)->Decrypt(
       encrypted_block,
       *encrypted_block_info);
 }
 
+void DeinitializeDecoder(PP_Instance instance,
+                         PP_StreamType decoder_type,
+                         uint32_t request_id) {
+  void* object =
+      Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
+  if (!object)
+    return;
+  static_cast<ContentDecryptor_Private*>(object)->DeinitializeDecoder(
+      decoder_type,
+      request_id);
+}
+
+void ResetDecoder(PP_Instance instance,
+                  PP_StreamType decoder_type,
+                  uint32_t request_id) {
+  void* object =
+      Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
+  if (!object)
+    return;
+  static_cast<ContentDecryptor_Private*>(object)->ResetDecoder(decoder_type,
+                                                               request_id);
+}
+
 void DecryptAndDecodeFrame(
     PP_Instance instance,
     PP_Resource encrypted_resource,
     const PP_EncryptedVideoFrameInfo* encrypted_video_frame_info) {
   void* object =
       Instance::GetPerInstanceObject(instance, kPPPContentDecryptorInterface);
   if (!object)
     return;
 
   pp::Buffer_Dev encrypted_frame(pp::PassRef(), encrypted_resource);
 
   static_cast<ContentDecryptor_Private*>(object)->DecryptAndDecodeFrame(
       encrypted_frame,
       *encrypted_video_frame_info);
 }
 
 const PPP_ContentDecryptor_Private ppp_content_decryptor = {
   &GenerateKeyRequest,
   &AddKey,
   &CancelKeyRequest,
   &Decrypt,
+  &DeinitializeDecoder,
+  &ResetDecoder,
   &DecryptAndDecodeFrame
 };
 
 template <> const char* interface_name<PPB_ContentDecryptor_Private>() {
   return PPB_CONTENTDECRYPTOR_PRIVATE_INTERFACE;
 }
 
 }  // namespace
 
 ContentDecryptor_Private::ContentDecryptor_Private(Instance* instance)
@@ skipping 74 matching lines @@
     pp::Buffer_Dev decrypted_block,
     const PP_DecryptedBlockInfo& decrypted_block_info) {
   if (has_interface<PPB_ContentDecryptor_Private>()) {
     get_interface<PPB_ContentDecryptor_Private>()->DeliverBlock(
         associated_instance_.pp_instance(),
         decrypted_block.pp_resource(),
         &decrypted_block_info);
   }
 }
 
+void ContentDecryptor_Private::DecoderDeinitializeDone(
+    PP_StreamType decoder_type,
+    uint32_t request_id) {
+  if (has_interface<PPB_ContentDecryptor_Private>()) {
+    get_interface<PPB_ContentDecryptor_Private>()->DecoderDeinitializeDone(
+        associated_instance_.pp_instance(),
+        decoder_type,
+        request_id);
+  }
+}
+
+void ContentDecryptor_Private::DecoderResetDone(PP_StreamType decoder_type,
+                                                uint32_t request_id) {
+  if (has_interface<PPB_ContentDecryptor_Private>()) {
+    get_interface<PPB_ContentDecryptor_Private>()->DecoderResetDone(
+        associated_instance_.pp_instance(),
+        decoder_type,
+        request_id);
+  }
+}
+
 void ContentDecryptor_Private::DeliverFrame(
     pp::Buffer_Dev decrypted_frame,
     const PP_DecryptedFrameInfo& decrypted_frame_info) {
   if (has_interface<PPB_ContentDecryptor_Private>()) {
     get_interface<PPB_ContentDecryptor_Private>()->DeliverFrame(
         associated_instance_.pp_instance(),
         decrypted_frame.pp_resource(),
         &decrypted_frame_info);
   }
 }
 
 void ContentDecryptor_Private::DeliverSamples(
     pp::Buffer_Dev decrypted_samples,
     const PP_DecryptedBlockInfo& decrypted_block_info) {
   if (has_interface<PPB_ContentDecryptor_Private>()) {
     get_interface<PPB_ContentDecryptor_Private>()->DeliverSamples(
         associated_instance_.pp_instance(),
         decrypted_samples.pp_resource(),
         &decrypted_block_info);
   }
 }
 
 }  // namespace pp