Changes to the EME Pepper 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 91 matching lines @@
                                       resource,
                                       &handle) == PP_FALSE)
     return false;
 
   buffer->resource = host_resource;
   buffer->handle = handle;
   buffer->size = size;
   return true;
 }
 
+void Initialize(PP_Instance instance,
+                PP_Var key_system,
+                const PP_KeySystemFlags* key_system_flags) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  std::string serialized_flags;
+  if (!SerializeBlockInfo(*key_system_flags, &serialized_flags)) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_Initialize(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+          instance,
+          SerializedVarSendInput(dispatcher, key_system),
+          serialized_flags));
+}
+
 void GenerateKeyRequest(PP_Instance instance,
-                        PP_Var key_system,
                         PP_Var type,
                         PP_Var init_data) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
   dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_GenerateKeyRequest(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
-          SerializedVarSendInput(dispatcher, key_system),
           SerializedVarSendInput(dispatcher, type),
           SerializedVarSendInput(dispatcher, init_data)));
 }
 
 void AddKey(PP_Instance instance,
             PP_Var session_id,
             PP_Var key,
             PP_Var init_data) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
@@ skipping 205 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,
   &GenerateKeyRequest,
   &AddKey,
   &CancelKeyRequest,
   &Decrypt,
   &InitializeAudioDecoder,
   &InitializeVideoDecoder,
   &DeinitializeDecoder,
   &ResetDecoder,
   &DecryptAndDecode
 };
@@ skipping 21 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_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_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,
+    const std::string& serialized_key_systems_flags) {
+  if (ppp_decryptor_impl_) {
+    PP_KeySystemFlags key_system_flags;
+    if (!DeserializeBlockInfo(serialized_key_systems_flags, &key_system_flags))

[dmichael (off chromium), 2013/09/18 22:52:32]

hmm, I probably never should have lgtmed
DeserializeBlockInfo/SerializeBlockInfo. It makes it easy to pass anything as a
string, which is almost always the wrong thing to do.

In this case, you could really just pass a bool. Or use the appropriate macros
to make the struct serializable in the top of ppapi/proxy/ppapi_messages.h

[jrummell, 2013/09/19 00:37:28]

Switched to pass a bool, and avoid the serialization issue.

+      return;
+    CallWhileUnlocked(ppp_decryptor_impl_->Initialize,
+                      instance,
+                      ExtractReceivedVarAndAddRef(dispatcher(), &key_system),
+                      const_cast<const PP_KeySystemFlags*>(&key_system_flags));

[ddorwin, 2013/09/18 22:22:24]

There's no way to pass structs by value or const ref?

[dmichael (off chromium), 2013/09/18 22:52:32]

No const-ref in C. You could technically use by-value, but we default to passing
structs by const-pointer in Pepper, (a) because some are large and (b) for
consistency.

+  }
+}
+
 void PPP_ContentDecryptor_Private_Proxy::OnMsgGenerateKeyRequest(
     PP_Instance instance,
-    SerializedVarReceiveInput key_system,
     SerializedVarReceiveInput type,
     SerializedVarReceiveInput init_data) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(ppp_decryptor_impl_->GenerateKeyRequest,
                       instance,
-                      ExtractReceivedVarAndAddRef(dispatcher(), &key_system),
                       ExtractReceivedVarAndAddRef(dispatcher(), &type),
                       ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgAddKey(
     PP_Instance instance,
     SerializedVarReceiveInput session_id,
     SerializedVarReceiveInput key,
     SerializedVarReceiveInput init_data) {
@@ skipping 136 matching lines @@
         ppp_decryptor_impl_->DecryptAndDecode,
         instance,
         decoder_type,
         plugin_resource.get(),
         const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi