Rename EME WD call parameters

content/renderer/pepper/content_decryptor_delegate.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 "content/renderer/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/safe_numerics.h"
@@ skipping 267 matching lines @@
     const media::SessionReadyCB& session_ready_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb) {
   session_created_cb_ = session_created_cb;
   session_message_cb_ = session_message_cb;
   session_ready_cb_ = session_ready_cb;
   session_closed_cb_ = session_closed_cb;
   session_error_cb_ = session_error_cb;
 }
 
-bool ContentDecryptorDelegate::CreateSession(uint32 reference_id,
+bool ContentDecryptorDelegate::CreateSession(uint32 session_id,
                                              const std::string& type,
                                              const uint8* init_data,
                                              int init_data_length) {
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
 
-  plugin_decryption_interface_->CreateSession(
-      pp_instance_,
-      reference_id,
-      StringVar::StringToPPVar(type),
-      init_data_array);
+  plugin_decryption_interface_->CreateSession(pp_instance_,
+                                              session_id,
+                                              StringVar::StringToPPVar(type),
+                                              init_data_array);
   return true;
 }
 
-bool ContentDecryptorDelegate::UpdateSession(uint32 reference_id,
+bool ContentDecryptorDelegate::UpdateSession(uint32 session_id,
                                              const uint8* response,
                                              int response_length) {
   PP_Var response_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           response_length, response);
   plugin_decryption_interface_->UpdateSession(
-      pp_instance_, reference_id, response_array);
+      pp_instance_, session_id, response_array);
   return true;
 }
 
-bool ContentDecryptorDelegate::ReleaseSession(uint32 reference_id) {
-  plugin_decryption_interface_->ReleaseSession(pp_instance_, reference_id);
+bool ContentDecryptorDelegate::ReleaseSession(uint32 session_id) {
+  plugin_decryption_interface_->ReleaseSession(pp_instance_, session_id);
   return true;
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
     media::Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
@@ skipping 256 matching lines @@
 
   // TODO(tomfinegan): Need to get stream type from media stack.
   ScopedPPResource pp_resource(encrypted_resource.get());
   plugin_decryption_interface_->DecryptAndDecode(pp_instance_,
                                                  PP_DECRYPTORSTREAMTYPE_VIDEO,
                                                  pp_resource,
                                                  &block_info);
   return true;
 }
 
-void ContentDecryptorDelegate::OnSessionCreated(uint32 reference_id,
-                                                PP_Var session_id_var) {
+void ContentDecryptorDelegate::OnSessionCreated(uint32 session_id,
+                                                PP_Var web_session_id_var) {
   if (session_created_cb_.is_null())
     return;
 
-  StringVar* session_id_string = StringVar::FromPPVar(session_id_var);
+  StringVar* session_id_string = StringVar::FromPPVar(web_session_id_var);
 
   if (!session_id_string) {
-    OnSessionError(reference_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  session_created_cb_.Run(reference_id, session_id_string->value());
+  session_created_cb_.Run(session_id, session_id_string->value());
 }
 
-void ContentDecryptorDelegate::OnSessionMessage(uint32 reference_id,
+void ContentDecryptorDelegate::OnSessionMessage(uint32 session_id,
                                                 PP_Var message_var,
                                                 PP_Var default_url_var) {
   if (session_message_cb_.is_null())
     return;
 
   ArrayBufferVar* message_array_buffer = ArrayBufferVar::FromPPVar(message_var);
 
   std::vector<uint8> message;
   if (message_array_buffer) {
     const uint8* data = static_cast<const uint8*>(message_array_buffer->Map());
     message.assign(data, data + message_array_buffer->ByteLength());
   }
 
   StringVar* default_url_string = StringVar::FromPPVar(default_url_var);
 
   if (!default_url_string) {
-    OnSessionError(reference_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  session_message_cb_.Run(reference_id, message, default_url_string->value());
+  session_message_cb_.Run(session_id, message, default_url_string->value());
 }
 
-void ContentDecryptorDelegate::OnSessionReady(uint32 reference_id) {
+void ContentDecryptorDelegate::OnSessionReady(uint32 session_id) {
   if (session_ready_cb_.is_null())
     return;
 
-  session_ready_cb_.Run(reference_id);
+  session_ready_cb_.Run(session_id);
 }
 
-void ContentDecryptorDelegate::OnSessionClosed(uint32 reference_id) {
+void ContentDecryptorDelegate::OnSessionClosed(uint32 session_id) {
   if (session_closed_cb_.is_null())
     return;
 
-  session_closed_cb_.Run(reference_id);
+  session_closed_cb_.Run(session_id);
 }
 
-void ContentDecryptorDelegate::OnSessionError(uint32 reference_id,
+void ContentDecryptorDelegate::OnSessionError(uint32 session_id,
                                               int32_t media_error,
                                               int32_t system_code) {
   if (session_error_cb_.is_null())
     return;
 
-  session_error_cb_.Run(reference_id,
+  session_error_cb_.Run(session_id,
                         static_cast<media::MediaKeys::KeyError>(media_error),
                         system_code);
 }
 
 void ContentDecryptorDelegate::DecoderInitializeDone(
      PP_DecryptorStreamType decoder_type,
      uint32_t request_id,
      PP_Bool success) {
   if (decoder_type == PP_DECRYPTORSTREAMTYPE_AUDIO) {
     // If the request ID is not valid or does not match what's saved, do
@@ skipping 406 matching lines @@
     frames->push_back(frame);
 
     cur += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace content