Update Pepper interface for EME

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/files/file.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/proxy/content_decryptor_private_serializer.h"
@@ skipping 106 matching lines @@
     return;
   }
 
   dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_Initialize(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
           SerializedVarSendInput(dispatcher, key_system)));
 }
 
+void SetServerCertificate(PP_Instance instance,
+                          uint32_t promise_id,
+                          PP_Var server_certificate) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_SetServerCertificate(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+      instance,
+      promise_id,
+      SerializedVarSendInput(dispatcher, server_certificate)));
+}
+
 void CreateSession(PP_Instance instance,
                    uint32_t promise_id,
                    PP_Var init_data_type,
                    PP_Var init_data,
                    PP_SessionType session_type) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
@@ skipping 34 matching lines @@
   }
 
   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_UpdateSession(
       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
       instance,
       promise_id,
       SerializedVarSendInput(dispatcher, web_session_id),
       SerializedVarSendInput(dispatcher, response)));
 }
 
-void ReleaseSession(PP_Instance instance,
-                    uint32_t promise_id,
-                    PP_Var web_session_id) {
+void GetUsableKeyIds(PP_Instance instance,
+                     uint32_t promise_id,
+                     PP_Var web_session_id) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
-  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_ReleaseSession(
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_GetUsableKeyIds(
       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
       instance,
       promise_id,
+      SerializedVarSendInput(dispatcher, web_session_id)));
+}
+
+void CloseSession(PP_Instance instance,
+                  uint32_t promise_id,
+                  PP_Var web_session_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CloseSession(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+      instance,
+      promise_id,
+      SerializedVarSendInput(dispatcher, web_session_id)));
+}
+
+void RemoveSession(PP_Instance instance,
+                   uint32_t promise_id,
+                   PP_Var web_session_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_RemoveSession(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+      instance,
+      promise_id,
       SerializedVarSendInput(dispatcher, web_session_id)));
 }
 
 void Decrypt(PP_Instance instance,
              PP_Resource encrypted_block,
              const PP_EncryptedBlockInfo* encrypted_block_info) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
@@ skipping 171 matching lines @@
   dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_DecryptAndDecode(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
           decoder_type,
           buffer,
           serialized_block_info));
 }
 
 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
-  &Initialize,
-  &CreateSession,
-  &LoadSession,
-  &UpdateSession,
-  &ReleaseSession,
-  &Decrypt,
-  &InitializeAudioDecoder,
-  &InitializeVideoDecoder,
-  &DeinitializeDecoder,
-  &ResetDecoder,
-  &DecryptAndDecode
-};
+    &Initialize,
+    &SetServerCertificate,
+    &CreateSession,
+    &LoadSession,
+    &UpdateSession,
+    &GetUsableKeyIds,

[ddorwin, 2014/08/22 20:49:21]

ditto

[jrummell, 2014/08/25 21:54:37]

Done.

+    &CloseSession,
+    &RemoveSession,
+    &Decrypt,
+    &InitializeAudioDecoder,
+    &InitializeVideoDecoder,
+    &DeinitializeDecoder,
+    &ResetDecoder,
+    &DecryptAndDecode};
 
 }  // namespace
 
 PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
     Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       ppp_decryptor_impl_(NULL) {
   if (dispatcher->IsPlugin()) {
     ppp_decryptor_impl_ = static_cast<const PPP_ContentDecryptor_Private*>(
         dispatcher->local_get_interface()(
@@ skipping 13 matching lines @@
 bool PPP_ContentDecryptor_Private_Proxy::OnMessageReceived(
     const IPC::Message& msg) {
   if (!dispatcher()->IsPlugin())
     return false;  // These are only valid from host->plugin.
                    // Don't allow the plugin to send these to the host.
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPP_ContentDecryptor_Private_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Initialize,
                         OnMsgInitialize)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_SetServerCertificate,
+                        OnMsgSetServerCertificate)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CreateSession,
                         OnMsgCreateSession)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_LoadSession,
                         OnMsgLoadSession)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_UpdateSession,
                         OnMsgUpdateSession)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_ReleaseSession,
-                        OnMsgReleaseSession)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_GetUsableKeyIds,
+                        OnMsgGetUsableKeyIds)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_CloseSession,
+                        OnMsgCloseSession)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_RemoveSession,
+                        OnMsgRemoveSession)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_Decrypt,
                         OnMsgDecrypt)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_InitializeAudioDecoder,
                         OnMsgInitializeAudioDecoder)
     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_DecryptAndDecode,
                         OnMsgDecryptAndDecode)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgInitialize(
     PP_Instance instance,
     SerializedVarReceiveInput key_system) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->Initialize,
         instance,
         ExtractReceivedVarAndAddRef(dispatcher(), &key_system));
   }
 }
 
+void PPP_ContentDecryptor_Private_Proxy::OnMsgSetServerCertificate(
+    PP_Instance instance,
+    uint32_t promise_id,
+    SerializedVarReceiveInput server_certificate) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->SetServerCertificate,
+        instance,
+        promise_id,
+        ExtractReceivedVarAndAddRef(dispatcher(), &server_certificate));
+  }
+}
+
 void PPP_ContentDecryptor_Private_Proxy::OnMsgCreateSession(
     PP_Instance instance,
     uint32_t promise_id,
     SerializedVarReceiveInput init_data_type,
     SerializedVarReceiveInput init_data,
     PP_SessionType session_type) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->CreateSession,
         instance,
@@ skipping 25 matching lines @@
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->UpdateSession,
         instance,
         promise_id,
         ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id),
         ExtractReceivedVarAndAddRef(dispatcher(), &response));
   }
 }
 
-void PPP_ContentDecryptor_Private_Proxy::OnMsgReleaseSession(
+void PPP_ContentDecryptor_Private_Proxy::OnMsgGetUsableKeyIds(
     PP_Instance instance,
     uint32_t promise_id,
     SerializedVarReceiveInput web_session_id) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
-        ppp_decryptor_impl_->ReleaseSession,
+        ppp_decryptor_impl_->GetUsableKeyIds,
         instance,
         promise_id,
         ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgCloseSession(
+    PP_Instance instance,
+    uint32_t promise_id,
+    SerializedVarReceiveInput web_session_id) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->CloseSession,
+        instance,
+        promise_id,
+        ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgRemoveSession(
+    PP_Instance instance,
+    uint32_t promise_id,
+    SerializedVarReceiveInput web_session_id) {
+  if (ppp_decryptor_impl_) {
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->RemoveSession,
+        instance,
+        promise_id,
+        ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgDecrypt(
     PP_Instance instance,
     const PPPDecryptor_Buffer& encrypted_buffer,
     const std::string& serialized_block_info) {
   ScopedPPResource plugin_resource(
       ScopedPPResource::PassRef(),
       PPB_Buffer_Proxy::AddProxyResource(encrypted_buffer.resource,
@@ skipping 110 matching lines @@
         ppp_decryptor_impl_->DecryptAndDecode,
         instance,
         decoder_type,
         plugin_resource.get(),
         const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi