Add Promises for EME (Chromium side)

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 107 matching lines @@
   }
 
   dispatcher->Send(
       new PpapiMsg_PPPContentDecryptor_Initialize(
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
           SerializedVarSendInput(dispatcher, key_system)));
 }
 
 void CreateSession(PP_Instance instance,
-                   uint32_t session_id,
-                   PP_Var type,
-                   PP_Var init_data) {
+                   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;
   }
 
   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CreateSession(
       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
       instance,
-      session_id,
-      SerializedVarSendInput(dispatcher, type),
-      SerializedVarSendInput(dispatcher, init_data)));
+      promise_id,
+      SerializedVarSendInput(dispatcher, init_data_type),
+      SerializedVarSendInput(dispatcher, init_data),
+      session_type));
 }
 
 void LoadSession(PP_Instance instance,
-                 uint32_t session_id,
+                 uint32_t promise_id,
                  PP_Var web_session_id) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_LoadSession(
       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
       instance,
-      session_id,
+      promise_id,
       SerializedVarSendInput(dispatcher, web_session_id)));
 }
 
-void UpdateSession(PP_Instance instance, uint32_t session_id, PP_Var response) {
+void UpdateSession(PP_Instance instance,
+                   uint32_t promise_id,
+                   PP_Var web_session_id,
+                   PP_Var response) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_UpdateSession(
       API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
       instance,
-      session_id,
+      promise_id,
+      SerializedVarSendInput(dispatcher, web_session_id),
       SerializedVarSendInput(dispatcher, response)));
 }
 
-void ReleaseSession(PP_Instance instance, uint32_t session_id) {
+void ReleaseSession(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(
-      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, session_id));
+      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 254 matching lines @@
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->Initialize,
         instance,
         ExtractReceivedVarAndAddRef(dispatcher(), &key_system));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgCreateSession(
     PP_Instance instance,
-    uint32_t session_id,
-    SerializedVarReceiveInput type,
-    SerializedVarReceiveInput init_data) {
+    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,
-                      session_id,
-                      ExtractReceivedVarAndAddRef(dispatcher(), &type),
-                      ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->CreateSession,
+        instance,
+        promise_id,
+        ExtractReceivedVarAndAddRef(dispatcher(), &init_data_type),
+        ExtractReceivedVarAndAddRef(dispatcher(), &init_data),
+        session_type);
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgLoadSession(
     PP_Instance instance,
-    uint32_t session_id,
+    uint32_t promise_id,
     SerializedVarReceiveInput web_session_id) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
         ppp_decryptor_impl_->LoadSession,
         instance,
-        session_id,
+        promise_id,
         ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgUpdateSession(
     PP_Instance instance,
-    uint32_t session_id,
+    uint32_t promise_id,
+    SerializedVarReceiveInput web_session_id,
     SerializedVarReceiveInput response) {
   if (ppp_decryptor_impl_) {
-    CallWhileUnlocked(ppp_decryptor_impl_->UpdateSession,
-                      instance,
-                      session_id,
-                      ExtractReceivedVarAndAddRef(dispatcher(), &response));
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->UpdateSession,
+        instance,
+        promise_id,
+        ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id),
+        ExtractReceivedVarAndAddRef(dispatcher(), &response));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgReleaseSession(
     PP_Instance instance,
-    uint32_t session_id) {
+    uint32_t promise_id,
+    SerializedVarReceiveInput web_session_id) {
   if (ppp_decryptor_impl_) {
-    CallWhileUnlocked(ppp_decryptor_impl_->ReleaseSession,
-                      instance,
-                      session_id);
+    CallWhileUnlocked(
+        ppp_decryptor_impl_->ReleaseSession,
+        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