Initialize the CDM asynchronously

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"
@@ skipping 94 matching lines @@
                                       &handle) == PP_FALSE)
     return false;
 
   buffer->resource = host_resource;
   buffer->handle = handle;
   buffer->size = size;
   return true;
 }
 
 void Initialize(PP_Instance instance,
+                uint32_t promise_id,
                 PP_Var key_system,
                 PP_Bool allow_distinctive_identifier,
                 PP_Bool allow_persistent_state) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
-  dispatcher->Send(
-      new PpapiMsg_PPPContentDecryptor_Initialize(
-          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
-          instance,
-          SerializedVarSendInput(dispatcher, key_system),
-          allow_distinctive_identifier,
-          allow_persistent_state));
+  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_Initialize(
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, promise_id,
+      SerializedVarSendInput(dispatcher, key_system),
+      allow_distinctive_identifier, allow_persistent_state));
 }
 
 void SetServerCertificate(PP_Instance instance,
                           uint32_t promise_id,
                           PP_Var server_certificate) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
@@ skipping 376 matching lines @@
     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,
+    uint32_t promise_id,
     SerializedVarReceiveInput key_system,
     PP_Bool allow_distinctive_identifier,
     PP_Bool allow_persistent_state) {
   if (ppp_decryptor_impl_) {
-    CallWhileUnlocked(
-        ppp_decryptor_impl_->Initialize,
-        instance,
-        ExtractReceivedVarAndAddRef(dispatcher(), &key_system),
-        allow_distinctive_identifier,
-        allow_persistent_state);
+    CallWhileUnlocked(ppp_decryptor_impl_->Initialize, instance, promise_id,
+                      ExtractReceivedVarAndAddRef(dispatcher(), &key_system),
+                      allow_distinctive_identifier, allow_persistent_state);
   }
 }
 
 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();
@@ skipping 196 matching lines @@
         ppp_decryptor_impl_->DecryptAndDecode,
         instance,
         decoder_type,
         plugin_resource.get(),
         &block_info);
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi