Rename EME WD call parameters

content/renderer/media/crypto/proxy_decryptor.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 "content/renderer/media/crypto/proxy_decryptor.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/crypto/content_decryption_module_factory.h"
 #if defined(OS_ANDROID)
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #endif  // defined(OS_ANDROID)
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
 namespace content {
 
 // Since these reference IDs may conflict with the ones generated in
 // WebContentDecryptionModuleSessionImpl for the short time both paths are
 // active, start with 100000 and generate the IDs from there.
 // TODO(jrummell): Only allow one path http://crbug.com/306680.
-uint32 ProxyDecryptor::next_reference_id_ = 100000;
+uint32 ProxyDecryptor::next_session_id_ = 100000;
 
-const uint32 INVALID_REFERENCE_ID = 0;
+const uint32 INVALID_SESSION_ID = 0;

[xhwang, 2013/12/05 18:51:37]

We use kCamelCase for consts.

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

Done.

 
 #if defined(ENABLE_PEPPER_CDMS)
 void ProxyDecryptor::DestroyHelperPlugin() {
   ContentDecryptionModuleFactory::DestroyHelperPlugin(
       web_media_player_client_, web_frame_);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 ProxyDecryptor::ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
@@ skipping 72 matching lines @@
 
   is_clear_key_ =
       media::IsClearKey(key_system) || media::IsExternalClearKey(key_system);
   return true;
 }
 
 bool ProxyDecryptor::GenerateKeyRequest(const std::string& type,
                                         const uint8* init_data,
                                         int init_data_length) {
   // Use a unique reference id for this request.
-  uint32 reference_id = next_reference_id_++;
+  uint32 session_id = next_session_id_++;
   if (!media_keys_->CreateSession(
-           reference_id, type, init_data, init_data_length)) {
+           session_id, type, init_data, init_data_length)) {
     media_keys_.reset();
     return false;
   }
 
   return true;
 }
 
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
-                            const std::string& session_id) {
+                            const std::string& web_session_id) {
   DVLOG(1) << "AddKey()";
 
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
-  uint32 reference_id = LookupReferenceId(session_id);
-  if (reference_id == INVALID_REFERENCE_ID) {
+  uint32 session_id = LookupReferenceId(web_session_id);
+  if (session_id == INVALID_SESSION_ID) {
     // Session hasn't been referenced before, so it is an error.
     // Note that the specification says "If sessionId is not null and is
     // unrecognized, throw an INVALID_ACCESS_ERR." However, for backwards
     // compatibility the error is not thrown, but rather reported as a
     // KeyError.
     key_error_cb_.Run(std::string(), media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   // EME WD spec only supports a single array passed to the CDM. For
   // Clear Key using v0.1b, both arrays are used (|init_data| is key_id).
   // Since the EME WD spec supports the key as a JSON Web Key,
   // convert the 2 arrays to a JWK and pass it as the single array.
   if (is_clear_key_) {
     // Decryptor doesn't support empty key ID (see http://crbug.com/123265).
     // So ensure a non-empty value is passed.
     if (!init_data) {
       static const uint8 kDummyInitData[1] = {0};
       init_data = kDummyInitData;
       init_data_length = arraysize(kDummyInitData);
     }
 
     std::string jwk =
         media::GenerateJWKSet(key, key_length, init_data, init_data_length);
     DCHECK(!jwk.empty());
     media_keys_->UpdateSession(
-        reference_id, reinterpret_cast<const uint8*>(jwk.data()), jwk.size());
+        session_id, reinterpret_cast<const uint8*>(jwk.data()), jwk.size());
     return;
   }
 
-  media_keys_->UpdateSession(reference_id, key, key_length);
+  media_keys_->UpdateSession(session_id, key, key_length);
 }
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
-  uint32 reference_id = LookupReferenceId(session_id);
-  if (reference_id == INVALID_REFERENCE_ID) {
+  uint32 session_reference_id = LookupReferenceId(session_id);
+  if (session_reference_id == INVALID_SESSION_ID) {
     // Session hasn't been created, so it is an error.
     key_error_cb_.Run(
         std::string(), media::MediaKeys::kUnknownError, 0);
   }
   else {
-    media_keys_->ReleaseSession(reference_id);
+    media_keys_->ReleaseSession(session_reference_id);
   }
 }
 
 scoped_ptr<media::MediaKeys> ProxyDecryptor::CreateMediaKeys(
     const std::string& key_system,
     const GURL& frame_url) {
   return ContentDecryptionModuleFactory::Create(
       key_system,
 #if defined(ENABLE_PEPPER_CDMS)
       web_media_player_client_,
@@ skipping 10 matching lines @@
       base::Bind(&ProxyDecryptor::OnSessionMessage,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProxyDecryptor::OnSessionReady,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProxyDecryptor::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProxyDecryptor::OnSessionError,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void ProxyDecryptor::OnSessionCreated(uint32 reference_id,
-                                      const std::string& session_id) {
+void ProxyDecryptor::OnSessionCreated(uint32 session_id,
+                                      const std::string& web_session_id) {
   // Due to heartbeat messages, OnSessionCreated() can get called multiple
   // times.
-  SessionIdMap::iterator it = sessions_.find(reference_id);
-  DCHECK(it == sessions_.end() || it->second == session_id);
+  SessionIdMap::iterator it = sessions_.find(session_id);
+  DCHECK(it == sessions_.end() || it->second == web_session_id);
   if (it == sessions_.end())
-    sessions_[reference_id] = session_id;
+    sessions_[session_id] = web_session_id;
 }
 
-void ProxyDecryptor::OnSessionMessage(uint32 reference_id,
+void ProxyDecryptor::OnSessionMessage(uint32 session_id,
                                       const std::vector<uint8>& message,
                                       const std::string& destination_url) {
   // Assumes that OnSessionCreated() has been called before this.
-  key_message_cb_.Run(LookupSessionId(reference_id), message, destination_url);
+  key_message_cb_.Run(LookupSessionId(session_id), message, destination_url);
 }
 
-void ProxyDecryptor::OnSessionReady(uint32 reference_id) {
+void ProxyDecryptor::OnSessionReady(uint32 session_id) {
   // Assumes that OnSessionCreated() has been called before this.
-  key_added_cb_.Run(LookupSessionId(reference_id));
+  key_added_cb_.Run(LookupSessionId(session_id));
 }
 
-void ProxyDecryptor::OnSessionClosed(uint32 reference_id) {
+void ProxyDecryptor::OnSessionClosed(uint32 session_id) {
   // No closed event in EME v0.1b.
 }
 
-void ProxyDecryptor::OnSessionError(uint32 reference_id,
+void ProxyDecryptor::OnSessionError(uint32 session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   // Assumes that OnSessionCreated() has been called before this.
-  key_error_cb_.Run(LookupSessionId(reference_id), error_code, system_code);
+  key_error_cb_.Run(LookupSessionId(session_id), error_code, system_code);
 }
 
 uint32 ProxyDecryptor::LookupReferenceId(const std::string& session_id) {
   for (SessionIdMap::iterator it = sessions_.begin();
        it != sessions_.end();
        ++it) {
     if (it->second == session_id)
       return it->first;
   }
 
   // If |session_id| is null, then use the single reference id.
   if (session_id.empty() && sessions_.size() == 1)
     return sessions_.begin()->first;
 
-  return INVALID_REFERENCE_ID;
+  return INVALID_SESSION_ID;
 }
 
-const std::string& ProxyDecryptor::LookupSessionId(uint32 reference_id) {
-  DCHECK_NE(reference_id, INVALID_REFERENCE_ID);
+const std::string& ProxyDecryptor::LookupSessionId(uint32 session_id) {
+  DCHECK_NE(session_id, INVALID_SESSION_ID);
 
   // Session may not exist if error happens during GenerateKeyRequest().
-  SessionIdMap::iterator it = sessions_.find(reference_id);
+  SessionIdMap::iterator it = sessions_.find(session_id);
   return (it != sessions_.end()) ? it->second : base::EmptyString();
 }
 
 }  // namespace content