Rename EME WD call parameters

ppapi/proxy/ppb_instance_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/ppb_instance_proxy.h"
 
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_time.h"
@@ skipping 525 matching lines @@
       PP_URLComponents_Dev* components) {
   ReceiveSerializedVarReturnValue result;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetPluginReferrerURL(
       API_ID_PPB_INSTANCE, instance, &result));
   return PPB_URLUtil_Shared::ConvertComponentsAndReturnURL(
       result.Return(dispatcher()),
       components);
 }
 
 void PPB_Instance_Proxy::SessionCreated(PP_Instance instance,
-                                        uint32_t reference_id,
-                                        PP_Var session_id) {
+                                        uint32_t session_id,
+                                        PP_Var web_session_id) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionCreated(
       API_ID_PPB_INSTANCE,
       instance,
-      reference_id,
-      SerializedVarSendInput(dispatcher(), session_id)));
+      session_id,
+      SerializedVarSendInput(dispatcher(), web_session_id)));
 }
 
 void PPB_Instance_Proxy::SessionMessage(PP_Instance instance,
-                                        uint32_t reference_id,
+                                        uint32_t session_id,
                                         PP_Var message,
                                         PP_Var destination_url) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionMessage(
       API_ID_PPB_INSTANCE,
       instance,
-      reference_id,
+      session_id,
       SerializedVarSendInput(dispatcher(), message),
       SerializedVarSendInput(dispatcher(), destination_url)));
 }
 
 void PPB_Instance_Proxy::SessionReady(PP_Instance instance,
-                                      uint32_t reference_id) {
+                                      uint32_t session_id) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionReady(
-      API_ID_PPB_INSTANCE, instance, reference_id));
+      API_ID_PPB_INSTANCE, instance, session_id));
 }
 
 void PPB_Instance_Proxy::SessionClosed(PP_Instance instance,
-                                       uint32_t reference_id) {
+                                       uint32_t session_id) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionClosed(
-      API_ID_PPB_INSTANCE, instance, reference_id));
+      API_ID_PPB_INSTANCE, instance, session_id));
 }
 
 void PPB_Instance_Proxy::SessionError(PP_Instance instance,
-                                      uint32_t reference_id,
+                                      uint32_t session_id,
                                       int32_t media_error,
                                       int32_t system_code) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionError(
-      API_ID_PPB_INSTANCE, instance, reference_id, media_error, system_code));
+      API_ID_PPB_INSTANCE, instance, session_id, media_error, system_code));
 }
 
 void PPB_Instance_Proxy::DeliverBlock(PP_Instance instance,
                                       PP_Resource decrypted_block,
                                       const PP_DecryptedBlockInfo* block_info) {
   PP_Resource decrypted_block_host_resource = 0;
 
   if (decrypted_block) {
     Resource* object =
         PpapiGlobals::Get()->GetResourceTracker()->GetResource(decrypted_block);
@@ skipping 448 matching lines @@
     return;
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetPluginReferrerURL(instance, NULL));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgSessionCreated(
     PP_Instance instance,
-    uint32_t reference_id,
-    SerializedVarReceiveInput session_id) {
+    uint32_t session_id,
+    SerializedVarReceiveInput web_session_id) {
   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
     return;
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->SessionCreated(
-        instance, reference_id, session_id.Get(dispatcher()));
+        instance, session_id, web_session_id.Get(dispatcher()));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgSessionMessage(
     PP_Instance instance,
-    uint32_t reference_id,
+    uint32_t session_id,
     SerializedVarReceiveInput message,
     SerializedVarReceiveInput destination_url) {
   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
     return;
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->SessionMessage(instance,
-                                      reference_id,
+                                      session_id,
                                       message.Get(dispatcher()),
                                       destination_url.Get(dispatcher()));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgSessionReady(PP_Instance instance,
-                                               uint32_t reference_id) {
+                                               uint32_t session_id) {
   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
     return;
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
-    enter.functions()->SessionReady(instance, reference_id);
+    enter.functions()->SessionReady(instance, session_id);
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgSessionClosed(PP_Instance instance,
-                                                uint32_t reference_id) {
+                                                uint32_t session_id) {
   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
     return;
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
-    enter.functions()->SessionClosed(instance, reference_id);
+    enter.functions()->SessionClosed(instance, session_id);
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgSessionError(PP_Instance instance,
-                                               uint32_t reference_id,
+                                               uint32_t session_id,
                                                int32_t media_error,
                                                int32_t system_error) {
   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
     return;
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->SessionError(
-        instance, reference_id, media_error, system_error);
+        instance, session_id, media_error, system_error);
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgDeliverBlock(
     PP_Instance instance,
     PP_Resource decrypted_block,
     const std::string& serialized_block_info) {
   if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
     return;
   PP_DecryptedBlockInfo block_info;
@@ skipping 161 matching lines @@
     PP_Instance instance) {
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return;  // Instance was probably deleted.
   data->should_do_request_surrounding_text = false;
 }
 
 }  // namespace proxy
 }  // namespace ppapi