Rename EME WD call parameters

media/cdm/ppapi/cdm_adapter.cc

 // Copyright 2013 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 "media/cdm/ppapi/cdm_adapter.h"
 
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/supported_cdm_versions.h"
 
 #if defined(CHECK_DOCUMENT_URL)
@@ skipping 229 matching lines @@
   PP_DCHECK(!key_system.empty());
   PP_DCHECK(key_system_.empty() || (key_system_ == key_system && cdm_));
 
   if (!cdm_ && !CreateCdmInstance(key_system))
     return;
 
   PP_DCHECK(cdm_);
   key_system_ = key_system;
 }
 
-void CdmAdapter::CreateSession(uint32_t reference_id,
+void CdmAdapter::CreateSession(uint32_t session_id,
                                const std::string& type,
                                pp::VarArrayBuffer init_data) {
   // Initialize() doesn't report an error, so CreateSession() can be called
   // even if Initialize() failed.
   if (!cdm_) {
-    OnSessionError(reference_id, cdm::kUnknownError, 0);
+    OnSessionError(session_id, cdm::kUnknownError, 0);
     return;
   }
 
 #if defined(CHECK_DOCUMENT_URL)
   PP_URLComponents_Dev url_components = {};
   const pp::URLUtil_Dev* url_util = pp::URLUtil_Dev::Get();
   if (!url_util) {
-    OnSessionError(reference_id, cdm::kUnknownError, 0);
+    OnSessionError(session_id, cdm::kUnknownError, 0);
     return;
   }
   pp::Var href = url_util->GetDocumentURL(
       pp::InstanceHandle(pp_instance()), &url_components);
   PP_DCHECK(href.is_string());
   PP_DCHECK(!href.AsString().empty());
   PP_DCHECK(url_components.host.begin);
   PP_DCHECK(0 < url_components.host.len);
 #endif  // defined(CHECK_DOCUMENT_URL)
 
-  cdm_->CreateSession(reference_id,
+  cdm_->CreateSession(session_id,
                       type.data(),
                       type.size(),
                       static_cast<const uint8_t*>(init_data.Map()),
                       init_data.ByteLength());
 }
 
-void CdmAdapter::UpdateSession(uint32_t reference_id,
+void CdmAdapter::UpdateSession(uint32_t session_id,
                                pp::VarArrayBuffer response) {
   // TODO(jrummell): In EME WD, AddKey() can only be called on valid sessions.
   // We should be able to DCHECK(cdm_) when addressing http://crbug.com/249976.
   if (!cdm_) {
-    OnSessionError(reference_id, cdm::kUnknownError, 0);
+    OnSessionError(session_id, cdm::kUnknownError, 0);
     return;
   }
 
   const uint8_t* response_ptr = static_cast<const uint8_t*>(response.Map());
   const uint32_t response_size = response.ByteLength();
 
   if (!response_ptr || response_size <= 0) {
-    OnSessionError(reference_id, cdm::kUnknownError, 0);
+    OnSessionError(session_id, cdm::kUnknownError, 0);
     return;
   }
   CdmWrapper::Result result =
-      cdm_->UpdateSession(reference_id, response_ptr, response_size);
+      cdm_->UpdateSession(session_id, response_ptr, response_size);
   switch (result) {
     case CdmWrapper::NO_ACTION:
       break;
     case CdmWrapper::CALL_KEY_ADDED:
-      OnSessionReady(reference_id);
+      OnSessionReady(session_id);
       break;
     case CdmWrapper::CALL_KEY_ERROR:
-      OnSessionError(reference_id, cdm::kUnknownError, 0);
+      OnSessionError(session_id, cdm::kUnknownError, 0);
       break;
   }
 }
 
-void CdmAdapter::ReleaseSession(uint32_t reference_id) {
+void CdmAdapter::ReleaseSession(uint32_t session_id) {
   // TODO(jrummell): In EME WD, AddKey() can only be called on valid sessions.
   // We should be able to DCHECK(cdm_) when addressing http://crbug.com/249976.
   if (!cdm_) {
-    OnSessionError(reference_id, cdm::kUnknownError, 0);
+    OnSessionError(session_id, cdm::kUnknownError, 0);
     return;
   }
 
-  CdmWrapper::Result result = cdm_->ReleaseSession(reference_id);
+  CdmWrapper::Result result = cdm_->ReleaseSession(session_id);
   switch (result) {
     case CdmWrapper::NO_ACTION:
       break;
     case CdmWrapper::CALL_KEY_ADDED:
       PP_NOTREACHED();
       break;
     case CdmWrapper::CALL_KEY_ERROR:
-      OnSessionError(reference_id, cdm::kUnknownError, 0);
+      OnSessionError(session_id, cdm::kUnknownError, 0);
       break;
   }
 }
 
 // Note: In the following decryption/decoding related functions, errors are NOT
 // reported via KeyError, but are reported via corresponding PPB calls.
 
 void CdmAdapter::Decrypt(pp::Buffer_Dev encrypted_buffer,
                          const PP_EncryptedBlockInfo& encrypted_block_info) {
   PP_DCHECK(!encrypted_buffer.is_null());
@@ skipping 190 matching lines @@
 }
 
 void CdmAdapter::SendKeyMessage(
     const char* session_id, uint32_t session_id_length,
     const char* message, uint32_t message_length,
     const char* default_url, uint32_t default_url_length) {
   PP_DCHECK(!key_system_.empty());
 
   std::string session_id_str(session_id, session_id_length);
   PP_DCHECK(!session_id_str.empty());
-  uint32_t reference_id = cdm_->DetermineReferenceId(session_id_str);
+  uint32_t session_reference_id = cdm_->DetermineReferenceId(session_id_str);

[ddorwin, 2013/12/05 00:44:52]

Is the naming here intentional?

[jrummell, 2013/12/06 23:42:35]

Yes. The old CDM APIs pass around the string as "session_id", not
"web_session_id", so I wanted to keep the parameters as specified.

[ddorwin, 2013/12/09 18:45:52]

So we can rename it when we remove CDM 1 & 2?

[jrummell, 2013/12/09 21:01:18]

It will be removed, since SendKeyMessage() and SendKeyError() aren't in CDM_3.

 
-  OnSessionCreated(reference_id, session_id, session_id_length);
-  OnSessionMessage(
-      reference_id, message, message_length, default_url, default_url_length);
+  OnSessionCreated(session_reference_id, session_id, session_id_length);
+  OnSessionMessage(session_reference_id,
+                   message, message_length,
+                   default_url, default_url_length);
 }
 
 void CdmAdapter::SendKeyError(const char* session_id,
                               uint32_t session_id_length,
                               cdm::MediaKeyError error_code,
                               uint32_t system_code) {
   std::string session_id_str(session_id, session_id_length);
-  uint32_t reference_id = cdm_->DetermineReferenceId(session_id_str);
-  OnSessionError(reference_id, error_code, system_code);
+  uint32_t session_reference_id = cdm_->DetermineReferenceId(session_id_str);
+  OnSessionError(session_reference_id, error_code, system_code);
 }
 
 void CdmAdapter::GetPrivateData(int32_t* instance,
                                 GetPrivateInterface* get_interface) {
   *instance = pp_instance();
   *get_interface = pp::Module::Get()->get_browser_interface();
 }
 
-void CdmAdapter::OnSessionCreated(uint32_t reference_id,
-                                  const char* session_id,
-                                  uint32_t session_id_length) {
+void CdmAdapter::OnSessionCreated(uint32_t session_id,
+                                  const char* web_session_id,
+                                  uint32_t web_session_id_length) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionCreatedInternal,
-      reference_id,
-      std::string(session_id, session_id_length)));
+      session_id,
+      std::string(web_session_id, web_session_id_length)));
 }
 
-void CdmAdapter::OnSessionMessage(uint32_t reference_id,
+void CdmAdapter::OnSessionMessage(uint32_t session_id,
                                   const char* message,
                                   uint32_t message_length,
                                   const char* destination_url,
                                   uint32_t destination_url_length) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionMessageInternal,
-      reference_id,
+      session_id,
       std::vector<uint8>(message, message + message_length),
       std::string(destination_url, destination_url_length)));
 }
 
-void CdmAdapter::OnSessionReady(uint32_t reference_id) {
+void CdmAdapter::OnSessionReady(uint32_t session_id) {
   PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionReadyInternal, reference_id));
+      &CdmAdapter::SendSessionReadyInternal, session_id));
 }
 
-void CdmAdapter::OnSessionClosed(uint32_t reference_id) {
+void CdmAdapter::OnSessionClosed(uint32_t session_id) {
   PostOnMain(callback_factory_.NewCallback(
-      &CdmAdapter::SendSessionClosedInternal, reference_id));
+      &CdmAdapter::SendSessionClosedInternal, session_id));
 }
 
-void CdmAdapter::OnSessionError(uint32_t reference_id,
+void CdmAdapter::OnSessionError(uint32_t session_id,
                                 cdm::MediaKeyError error_code,
                                 uint32_t system_code) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::SendSessionErrorInternal,
-      reference_id,
+      session_id,
       error_code,
       system_code));
 }
 
 void CdmAdapter::SendSessionCreatedInternal(int32_t result,
-                                            uint32_t reference_id,
-                                            const std::string& session_id) {
+                                            uint32_t session_id,
+                                            const std::string& web_session_id) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::SessionCreated(reference_id, session_id);
+  pp::ContentDecryptor_Private::SessionCreated(session_id, web_session_id);
 }
 
 void CdmAdapter::SendSessionMessageInternal(int32_t result,
-                                            uint32_t reference_id,
+                                            uint32_t session_id,
                                             const std::vector<uint8>& message,
                                             const std::string& default_url) {
   PP_DCHECK(result == PP_OK);
 
   pp::VarArrayBuffer message_array_buffer(message.size());
   if (message.size() > 0) {
     memcpy(message_array_buffer.Map(), message.data(), message.size());
   }
 
   pp::ContentDecryptor_Private::SessionMessage(
-      reference_id, message_array_buffer, default_url);
+      session_id, message_array_buffer, default_url);
 }
 
-void CdmAdapter::SendSessionReadyInternal(int32_t result,
-                                          uint32_t reference_id) {
+void CdmAdapter::SendSessionReadyInternal(int32_t result, uint32_t session_id) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::SessionReady(reference_id);
+  pp::ContentDecryptor_Private::SessionReady(session_id);
 }
 
 void CdmAdapter::SendSessionClosedInternal(int32_t result,
-                                           uint32_t reference_id) {
+                                           uint32_t session_id) {
   PP_DCHECK(result == PP_OK);
-  pp::ContentDecryptor_Private::SessionClosed(reference_id);
+  pp::ContentDecryptor_Private::SessionClosed(session_id);
 }
 
 void CdmAdapter::SendSessionErrorInternal(int32_t result,
-                                          uint32_t reference_id,
+                                          uint32_t session_id,
                                           cdm::MediaKeyError error_code,
                                           uint32_t system_code) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::SessionError(
-      reference_id, error_code, system_code);
+      session_id, error_code, system_code);
 }
 
 void CdmAdapter::DeliverBlock(int32_t result,
                               const cdm::Status& status,
                               const LinkedDecryptedBlock& decrypted_block,
                               const PP_DecryptTrackingInfo& tracking_info) {
   PP_DCHECK(result == PP_OK);
   PP_DecryptedBlockInfo decrypted_block_info;
   decrypted_block_info.tracking_info = tracking_info;
   decrypted_block_info.tracking_info.timestamp = decrypted_block->Timestamp();
@@ skipping 350 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp