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 "media/base/limits.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/proxy/content_decryptor_private_serializer.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_buffer_proxy.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
+#include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "ppapi/thunk/ppb_instance_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Instance_API;
 
@@ skipping 89 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;
+  }
+
+  ArrayBufferVar* server_certificate_buffer =
+      ArrayBufferVar::FromPPVar(server_certificate);
+  if (!server_certificate_buffer ||
+      server_certificate_buffer->ByteLength() <
+          media::limits::kMinCertificateLength ||
+      server_certificate_buffer->ByteLength() >
+          media::limits::kMaxCertificateLength) {
+    NOTREACHED();
+    return;
+  }
+
+  const uint8_t* server_certificate_ptr =
+      static_cast<const uint8_t*>(server_certificate_buffer->Map());
+  const uint32_t server_certificate_size =
+      server_certificate_buffer->ByteLength();
+  std::vector<uint8_t> server_certificate_vector(
+      server_certificate_ptr, server_certificate_ptr + server_certificate_size);
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_SetServerCertificate(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+      instance,
+      promise_id,
+      server_certificate_vector));
+}
+
 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 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_ReleaseSession(
+  StringVar* session_id = StringVar::FromPPVar(web_session_id);
+  if (!session_id ||
+      session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CloseSession(
       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
       instance,
       promise_id,
-      SerializedVarSendInput(dispatcher, web_session_id)));
+      session_id->value()));
+}
+
+void RemoveSession(PP_Instance instance,
+                   uint32_t promise_id,
+                   PP_Var web_session_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  StringVar* session_id = StringVar::FromPPVar(web_session_id);
+  if (!session_id ||
+      session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_RemoveSession(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+      instance,
+      promise_id,
+      session_id->value()));
+}
+
+void GetUsableKeyIds(PP_Instance instance,
+                     uint32_t promise_id,
+                     PP_Var web_session_id) {
+  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
+  if (!dispatcher) {
+    NOTREACHED();
+    return;
+  }
+
+  StringVar* session_id = StringVar::FromPPVar(web_session_id);
+  if (!session_id ||
+      session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_GetUsableKeyIds(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
+      instance,
+      promise_id,
+      session_id->value()));
 }
 
 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 170 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,
+    &CloseSession,
+    &RemoveSession,
+    &GetUsableKeyIds,
+    &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_CloseSession,
+                        OnMsgCloseSession)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_RemoveSession,
+                        OnMsgRemoveSession)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_GetUsableKeyIds,
+                        OnMsgGetUsableKeyIds)
     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,
+    std::vector<uint8_t> server_certificate) {
+  if (server_certificate.size() < media::limits::kMinCertificateLength ||
+      server_certificate.size() > media::limits::kMaxCertificateLength) {
+    NOTREACHED();
+    return;
+  }
+
+  if (ppp_decryptor_impl_) {
+    ScopedPPVar server_certificate_var(
+        ScopedPPVar::PassRef(),
+        PpapiGlobals::Get()
+            ->GetVarTracker()
+            ->MakeArrayBufferPPVar(server_certificate.size(),
+                                   &server_certificate[0]));
+    CallWhileUnlocked(ppp_decryptor_impl_->SetServerCertificate,
+                      instance,
+                      promise_id,
+                      server_certificate_var.get());
+  }
+}
+
 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::OnMsgCloseSession(
     PP_Instance instance,
     uint32_t promise_id,
-    SerializedVarReceiveInput web_session_id) {
+    const std::string& web_session_id) {
   if (ppp_decryptor_impl_) {
-    CallWhileUnlocked(
-        ppp_decryptor_impl_->ReleaseSession,
-        instance,
-        promise_id,
-        ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
+    ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+                                   StringVar::StringToPPVar(web_session_id));
+    CallWhileUnlocked(ppp_decryptor_impl_->CloseSession,
+                      instance,
+                      promise_id,
+                      web_session_id_var.get());
   }
 }
 
+void PPP_ContentDecryptor_Private_Proxy::OnMsgRemoveSession(
+    PP_Instance instance,
+    uint32_t promise_id,
+    const std::string& web_session_id) {
+  if (ppp_decryptor_impl_) {
+    ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+                                   StringVar::StringToPPVar(web_session_id));
+    CallWhileUnlocked(ppp_decryptor_impl_->RemoveSession,
+                      instance,
+                      promise_id,
+                      web_session_id_var.get());
+  }
+}
+
+void PPP_ContentDecryptor_Private_Proxy::OnMsgGetUsableKeyIds(
+    PP_Instance instance,
+    uint32_t promise_id,
+    const std::string& web_session_id) {
+  if (ppp_decryptor_impl_) {
+    ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+                                   StringVar::StringToPPVar(web_session_id));
+    CallWhileUnlocked(ppp_decryptor_impl_->GetUsableKeyIds,
+                      instance,
+                      promise_id,
+                      web_session_id_var.get());
+  }
+}
+
 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,
                                          encrypted_buffer.handle,
                                          encrypted_buffer.size));
   if (ppp_decryptor_impl_) {
@@ skipping 107 matching lines @@
         ppp_decryptor_impl_->DecryptAndDecode,
         instance,
         decoder_type,
         plugin_resource.get(),
         const_cast<const PP_EncryptedBlockInfo*>(&block_info));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi