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

ppapi/proxy/ppp_content_decryptor_private_proxy.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/proxy/ppp_content_decryptor_private_proxy.h"
 
 #include "base/platform_file.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/proxy/content_decryptor_private_serializer.h"
@@ skipping 220 matching lines @@
 
   dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
           serialized_decoder_config,
           buffer));
 }
 
 
+void DeinitializeDecoder(PP_Instance instance,
+                         PP_DecryptorStreamType decoder_type,
+                         uint32_t request_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_DeinitializeDecoder(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          decoder_type,
+          request_id));
+}
+
+void ResetDecoder(PP_Instance instance,
+                  PP_DecryptorStreamType decoder_type,
+                  uint32_t request_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_ResetDecoder(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          decoder_type,
+          request_id));
+}
+
 void DecryptAndDecodeFrame(
     PP_Instance instance,
     PP_Resource encrypted_frame,
     const PP_EncryptedVideoFrameInfo* encrypted_video_frame_info) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
@@ skipping 20 matching lines @@
           buffer,
           serialized_frame_info));
 }
 
 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
   &GenerateKeyRequest,
   &AddKey,
   &CancelKeyRequest,
   &Decrypt,
   &InitializeVideoDecoder,
+  &DeinitializeDecoder,
+  &ResetDecoder,
   &DecryptAndDecodeFrame
 };
 
 }  // namespace
 
 PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
     Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       ppp_decryptor_impl_(NULL) {
   if (dispatcher->IsPlugin()) {
@@ skipping 19 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_GenerateKeyRequest,
                         OnMsgGenerateKeyRequest)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_AddKey,
                         OnMsgAddKey)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CancelKeyRequest,
                         OnMsgCancelKeyRequest)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Decrypt,
                         OnMsgDecrypt)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeVideoDecoder,
                         OnMsgInitializeVideoDecoder)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DeinitializeDecoder,
+                        OnMsgDeinitializeDecoder)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_ResetDecoder,
+                        OnMsgResetDecoder)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_DecryptAndDecodeFrame,
                         OnMsgDecryptAndDecodeFrame)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgGenerateKeyRequest(
     PP_Instance instance,
@@ skipping 69 matching lines @@
     }
 
     CallWhileUnlocked(
         ppp_decryptor_impl_->InitializeVideoDecoder,
         instance,
         const_cast<const PP_VideoDecoderConfig*>(&decoder_config),
         plugin_resource);
   }
 }
 
+void PPP_ContentDecryptor_Private_Proxy::OnMsgDeinitializeDecoder(
+    PP_Instance instance,
+    PP_DecryptorStreamType decoder_type,
+    uint32_t request_id) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->DeinitializeDecoder,
+        instance,
+        decoder_type,
+        request_id);
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgResetDecoder(
+    PP_Instance instance,
+    PP_DecryptorStreamType decoder_type,
+    uint32_t request_id) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->ResetDecoder,
+        instance,
+        decoder_type,
+        request_id);
+  }
+}
+
 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecryptAndDecodeFrame(
     PP_Instance instance,
     const PPPDecryptor_Buffer& encrypted_frame,
     const std::string& serialized_frame_info) {
   if (ppp_decryptor_impl_) {
     PP_Resource plugin_resource =
         PPB_Buffer_Proxy::AddProxyResource(encrypted_frame.resource,
                                            encrypted_frame.handle,
                                            encrypted_frame.size);
     PP_EncryptedVideoFrameInfo frame_info;
     if (!DeserializeBlockInfo(serialized_frame_info, &frame_info))
       return;
     CallWhileUnlocked(
         ppp_decryptor_impl_->DecryptAndDecodeFrame,
         instance,
         plugin_resource,
         const_cast<const PP_EncryptedVideoFrameInfo*>(&frame_info));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi