Rename EME WD call parameters

media/cdm/ppapi/clear_key_cdm.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/clear_key_cdm.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
@@ skipping 141 matching lines @@
       host, key_system_string == kExternalClearKeyDecryptOnlyKeySystem);
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 // Since all the calls to AesDecryptor are synchronous, pass a dummy value for
-// reference_id that is never exposed outside this class.
+// session_id that is never exposed outside this class.
 // TODO(jrummell): Remove usage of this when the CDM interface is updated
-// to use reference_id.
+// to use session_id.
 
 ClearKeyCdm::Client::Client()
     : status_(kNone), error_code_(MediaKeys::kUnknownError), system_code_(0) {}
 
 ClearKeyCdm::Client::~Client() {}
 
 void ClearKeyCdm::Client::Reset() {
   status_ = kNone;
-  session_id_.clear();
+  web_session_id_.clear();
   message_.clear();
   destination_url_.clear();
   error_code_ = MediaKeys::kUnknownError;
   system_code_ = 0;
 }
 
-void ClearKeyCdm::Client::OnSessionCreated(uint32 reference_id,
-                                           const std::string& session_id) {
+void ClearKeyCdm::Client::OnSessionCreated(uint32 session_id,
+                                           const std::string& web_session_id) {
   status_ = static_cast<Status>(status_ | kCreated);
-  session_id_ = session_id;
+  web_session_id_ = web_session_id;
 }
 
-void ClearKeyCdm::Client::OnSessionMessage(uint32 reference_id,
+void ClearKeyCdm::Client::OnSessionMessage(uint32 session_id,
                                            const std::vector<uint8>& message,
                                            const std::string& destination_url) {
   status_ = static_cast<Status>(status_ | kMessage);
   message_ = message;
   destination_url_ = destination_url;
 }
 
-void ClearKeyCdm::Client::OnSessionReady(uint32 reference_id) {
+void ClearKeyCdm::Client::OnSessionReady(uint32 session_id) {
   status_ = static_cast<Status>(status_ | kReady);
 }
 
-void ClearKeyCdm::Client::OnSessionClosed(uint32 reference_id) {
+void ClearKeyCdm::Client::OnSessionClosed(uint32 session_id) {
   status_ = static_cast<Status>(status_ | kClosed);
 }
 
-void ClearKeyCdm::Client::OnSessionError(uint32 reference_id,
+void ClearKeyCdm::Client::OnSessionError(uint32 session_id,
                                          media::MediaKeys::KeyError error_code,
                                          int system_code) {
   status_ = static_cast<Status>(status_ | kError);
   error_code_ = error_code;
   system_code_ = system_code;
 }
 
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host, bool is_decrypt_only)
     : decryptor_(
           base::Bind(&Client::OnSessionCreated, base::Unretained(&client_)),
@@ skipping 16 matching lines @@
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
 cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type,
                                             uint32_t type_size,
                                             const uint8_t* init_data,
                                             uint32_t init_data_size) {
   DVLOG(1) << "GenerateKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.CreateSession(MediaKeys::kInvalidReferenceId,
+  decryptor_.CreateSession(MediaKeys::kInvalidSessionId,
                            std::string(type, type_size),
                            init_data, init_data_size);
 
   if (client_.status() != (Client::kMessage | Client::kCreated)) {
     // Use values returned to client if possible.
-    host_->SendKeyError(client_.session_id().data(),
-                        client_.session_id().size(),
+    host_->SendKeyError(client_.web_session_id().data(),
+                        client_.web_session_id().size(),
                         static_cast<cdm::MediaKeyError>(client_.error_code()),
                         client_.system_code());
     return cdm::kSessionError;
   }
 
   host_->SendKeyMessage(
-      client_.session_id().data(), client_.session_id().size(),
+      client_.web_session_id().data(), client_.web_session_id().size(),
       reinterpret_cast<const char*>(&client_.message()[0]),
       client_.message().size(),
       client_.destination_url().data(), client_.destination_url().size());
 
   // Only save the latest session ID for heartbeat messages.
-  heartbeat_session_id_ = client_.session_id();
+  heartbeat_session_id_ = client_.web_session_id();
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::AddKey(const char* session_id,
                                 uint32_t session_id_size,
                                 const uint8_t* key,
                                 uint32_t key_size,
                                 const uint8_t* key_id,
                                 uint32_t key_id_size) {
   DVLOG(1) << "AddKey()";
   DCHECK(!key_id && !key_id_size);
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.UpdateSession(MediaKeys::kInvalidReferenceId, key, key_size);
+  decryptor_.UpdateSession(MediaKeys::kInvalidSessionId, key, key_size);
 
   if (client_.status() != Client::kReady) {
     host_->SendKeyError(session_id, session_id_size,
                         static_cast<cdm::MediaKeyError>(client_.error_code()),
                         client_.system_code());
     return cdm::kSessionError;
   }
 
   if (!timer_set_) {
     ScheduleNextHeartBeat();
     timer_set_ = true;
   }
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::CancelKeyRequest(const char* session_id,
                                           uint32_t session_id_size) {
   DVLOG(1) << "CancelKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
-  decryptor_.ReleaseSession(MediaKeys::kInvalidReferenceId);
+  decryptor_.ReleaseSession(MediaKeys::kInvalidSessionId);
 
   // No message normally sent by Release(), but if an error occurred,
   // report it as a failure.
   if (client_.status() == Client::kError) {
     host_->SendKeyError(session_id, session_id_size,
                         static_cast<cdm::MediaKeyError>(client_.error_code()),
                         client_.system_code());
     return cdm::kSessionError;
   }
 
@@ skipping 308 matching lines @@
   int samples_generated = GenerateFakeAudioFramesFromDuration(
       timestamp_in_microseconds - CurrentTimeStampInMicroseconds(),
       audio_frames);
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 }  // namespace media