Changes to support CDM_7

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 142 matching lines @@
   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) {
+void CreateSessionAndGenerateRequest(PP_Instance instance,
+                                     uint32_t promise_id,
+                                     PP_SessionType session_type,
+                                     PP_Var init_data_type,
+                                     PP_Var init_data) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
-  dispatcher->Send(new PpapiMsg_PPPContentDecryptor_CreateSession(
-      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
-      instance,
-      promise_id,
-      SerializedVarSendInput(dispatcher, init_data_type),
-      SerializedVarSendInput(dispatcher, init_data),
-      session_type));
+  dispatcher->Send(
+      new PpapiMsg_PPPContentDecryptor_CreateSessionAndGenerateRequest(
+          API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, promise_id,
+          session_type, SerializedVarSendInput(dispatcher, init_data_type),
+          SerializedVarSendInput(dispatcher, init_data)));
 }
 
 void LoadSession(PP_Instance instance,
                  uint32_t promise_id,
+                 PP_SessionType session_type,
                  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,
-      promise_id,
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, promise_id, session_type,
       SerializedVarSendInput(dispatcher, web_session_id)));
 }
 
 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();
@@ skipping 47 matching lines @@
     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;
   }
 
   PPPDecryptor_Buffer buffer;
@@ skipping 170 matching lines @@
           API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE,
           instance,
           decoder_type,
           buffer,
           serialized_block_info));
 }
 
 static const PPP_ContentDecryptor_Private content_decryptor_interface = {
     &Initialize,
     &SetServerCertificate,
-    &CreateSession,
+    &CreateSessionAndGenerateRequest,
     &LoadSession,
     &UpdateSession,
     &CloseSession,
     &RemoveSession,
-    &GetUsableKeyIds,
     &Decrypt,
     &InitializeAudioDecoder,
     &InitializeVideoDecoder,
     &DeinitializeDecoder,
     &ResetDecoder,
     &DecryptAndDecode};
 
 }  // namespace
 
 PPP_ContentDecryptor_Private_Proxy::PPP_ContentDecryptor_Private_Proxy(
@@ skipping 21 matching lines @@
   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_CreateSessionAndGenerateRequest,
+        OnMsgCreateSessionAndGenerateRequest)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_LoadSession,
                         OnMsgLoadSession)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPContentDecryptor_UpdateSession,
                         OnMsgUpdateSession)
     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)
@@ skipping 33 matching lines @@
             ->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(
+void PPP_ContentDecryptor_Private_Proxy::OnMsgCreateSessionAndGenerateRequest(
     PP_Instance instance,
     uint32_t promise_id,
+    PP_SessionType session_type,
     SerializedVarReceiveInput init_data_type,
-    SerializedVarReceiveInput init_data,
-    PP_SessionType session_type) {
+    SerializedVarReceiveInput init_data) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
-        ppp_decryptor_impl_->CreateSession,
-        instance,
-        promise_id,
+        ppp_decryptor_impl_->CreateSessionAndGenerateRequest, instance,
+        promise_id, session_type,
         ExtractReceivedVarAndAddRef(dispatcher(), &init_data_type),
-        ExtractReceivedVarAndAddRef(dispatcher(), &init_data),
-        session_type);
+        ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgLoadSession(
     PP_Instance instance,
     uint32_t promise_id,
+    PP_SessionType session_type,
     SerializedVarReceiveInput web_session_id) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(
-        ppp_decryptor_impl_->LoadSession,
-        instance,
-        promise_id,
+        ppp_decryptor_impl_->LoadSession, instance, promise_id, session_type,
         ExtractReceivedVarAndAddRef(dispatcher(), &web_session_id));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgUpdateSession(
     PP_Instance instance,
     uint32_t promise_id,
     SerializedVarReceiveInput web_session_id,
     SerializedVarReceiveInput response) {
   if (ppp_decryptor_impl_) {
@@ skipping 27 matching lines @@
   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(),
         &block_info);
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi