Rename EME WD call parameters

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 reference_id,
+                   uint32_t session_id,
                    PP_Var 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,
-      reference_id,
+      session_id,
       SerializedVarSendInput(dispatcher, type),
       SerializedVarSendInput(dispatcher, init_data)));
 }
 
-void UpdateSession(PP_Instance instance,
-                   uint32_t reference_id,
-                   PP_Var response) {
+void UpdateSession(PP_Instance instance, uint32_t 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,
-      reference_id,
+      session_id,
       SerializedVarSendInput(dispatcher, response)));
 }
 
-void ReleaseSession(PP_Instance instance, uint32_t reference_id) {
+void ReleaseSession(PP_Instance instance, uint32_t session_id) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
 
   dispatcher->Send(new PpapiMsg_PPPContentDecryptor_ReleaseSession(
-      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, reference_id));
+      API_ID_PPP_CONTENT_DECRYPTOR_PRIVATE, instance, 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 251 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 reference_id,
+    uint32_t session_id,
     SerializedVarReceiveInput type,
     SerializedVarReceiveInput init_data) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(ppp_decryptor_impl_->CreateSession,
                       instance,
-                      reference_id,
+                      session_id,
                       ExtractReceivedVarAndAddRef(dispatcher(), &type),
                       ExtractReceivedVarAndAddRef(dispatcher(), &init_data));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgUpdateSession(
     PP_Instance instance,
-    uint32_t reference_id,
+    uint32_t session_id,
     SerializedVarReceiveInput response) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(ppp_decryptor_impl_->UpdateSession,
                       instance,
-                      reference_id,
+                      session_id,
                       ExtractReceivedVarAndAddRef(dispatcher(), &response));
   }
 }
 
 void PPP_ContentDecryptor_Private_Proxy::OnMsgReleaseSession(
     PP_Instance instance,
-    uint32_t reference_id) {
+    uint32_t session_id) {
   if (ppp_decryptor_impl_) {
     CallWhileUnlocked(ppp_decryptor_impl_->ReleaseSession,
                       instance,
-                      reference_id);
+                      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