Rename EME WD call parameters

media/base/android/media_drm_bridge.cc

 // Copyright (c) 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/base/android/media_drm_bridge.h"
 
 #include "base/android/build_info.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/callback_helpers.h"
@@ skipping 218 matching lines @@
       env, j_scheme_uuid.obj(), j_security_level.obj(),
       reinterpret_cast<intptr_t>(this)));
 }
 
 MediaDrmBridge::~MediaDrmBridge() {
   JNIEnv* env = AttachCurrentThread();
   if (!j_media_drm_.is_null())
     Java_MediaDrmBridge_release(env, j_media_drm_.obj());
 }
 
-bool MediaDrmBridge::CreateSession(uint32 reference_id,
+bool MediaDrmBridge::CreateSession(uint32 session_id,
                                    const std::string& type,
                                    const uint8* init_data,
                                    int init_data_length) {
   std::vector<uint8> pssh_data;
   if (!GetPsshData(init_data, init_data_length, scheme_uuid_, &pssh_data))
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_pssh_data =
       base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, type);
-  pending_key_request_reference_ids_.push(reference_id);
+  pending_key_request_session_ids_.push(session_id);
   Java_MediaDrmBridge_generateKeyRequest(
       env, j_media_drm_.obj(), j_pssh_data.obj(), j_mime.obj());
   return true;
 }
 
-void MediaDrmBridge::UpdateSession(uint32 reference_id,
+void MediaDrmBridge::UpdateSession(uint32 session_id,
                                    const uint8* response,
                                    int response_length) {
   DVLOG(1) << __FUNCTION__;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_response =
       base::android::ToJavaByteArray(env, response, response_length);
   ScopedJavaLocalRef<jstring> j_session_id =
-      ConvertUTF8ToJavaString(env, LookupSessionId(reference_id));
+      ConvertUTF8ToJavaString(env, LookupSessionId(session_id));
   // TODO(jrummell): Update Android names to match new functionality.
   Java_MediaDrmBridge_addKey(
       env, j_media_drm_.obj(), j_session_id.obj(), j_response.obj());
 }
 
-void MediaDrmBridge::ReleaseSession(uint32 reference_id) {
+void MediaDrmBridge::ReleaseSession(uint32 session_id) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_session_id =
-      ConvertUTF8ToJavaString(env, LookupSessionId(reference_id));
+      ConvertUTF8ToJavaString(env, LookupSessionId(session_id));
   Java_MediaDrmBridge_cancelKeyRequest(
       env, j_media_drm_.obj(), j_session_id.obj());
 }
 
 void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
   if (closure.is_null()) {
     media_crypto_ready_cb_.Reset();
     return;
   }
 
@@ skipping 11 matching lines @@
   DCHECK(!GetMediaCrypto().is_null());
   if (!media_crypto_ready_cb_.is_null())
     base::ResetAndReturn(&media_crypto_ready_cb_).Run();
 }
 
 void MediaDrmBridge::OnKeyMessage(JNIEnv* env,
                                   jobject j_media_drm,
                                   jstring j_session_id,
                                   jbyteArray j_message,
                                   jstring j_destination_url) {
-  std::string session_id = ConvertJavaStringToUTF8(env, j_session_id);
-  uint32_t reference_id = DetermineReferenceId(session_id);
+  std::string web_session_id = ConvertJavaStringToUTF8(env, j_session_id);
+  uint32_t session_id = DetermineReferenceId(web_session_id);
   std::vector<uint8> message;
   JavaByteArrayToByteVector(env, j_message, &message);
   std::string destination_url = ConvertJavaStringToUTF8(env, j_destination_url);
 
-  manager_->OnSessionCreated(media_keys_id_, reference_id, session_id);
+  manager_->OnSessionCreated(media_keys_id_, session_id, web_session_id);
   manager_->OnSessionMessage(
-      media_keys_id_, reference_id, message, destination_url);
+      media_keys_id_, session_id, message, destination_url);
 }
 
 void MediaDrmBridge::OnKeyAdded(JNIEnv* env, jobject, jstring j_session_id) {
-  std::string session_id = ConvertJavaStringToUTF8(env, j_session_id);
-  uint32_t reference_id = DetermineReferenceId(session_id);
-  manager_->OnSessionReady(media_keys_id_, reference_id);
+  std::string web_session_id = ConvertJavaStringToUTF8(env, j_session_id);

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

Is MediaDrm passing us sessionId instead of "reference ID"? So, this will be the
last place where we don't have "reference ID", even after eliminating the
prefixed API?

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

I'll fix MediaDrmBridge so that it'll pass back a "reference ID" (aka, the new
integer sessionId).

+  uint32_t session_id = DetermineReferenceId(web_session_id);
+  manager_->OnSessionReady(media_keys_id_, session_id);
 }
 
 void MediaDrmBridge::OnKeyError(JNIEnv* env, jobject, jstring j_session_id) {
   // |j_session_id| can be NULL, in which case we'll return an empty string.
-  std::string session_id = ConvertJavaStringToUTF8(env, j_session_id);
-  uint32 reference_id = DetermineReferenceId(session_id);
+  std::string web_session_id = ConvertJavaStringToUTF8(env, j_session_id);
+  uint32 session_id = DetermineReferenceId(web_session_id);
   manager_->OnSessionError(
-      media_keys_id_, reference_id, MediaKeys::kUnknownError, 0);
+      media_keys_id_, session_id, MediaKeys::kUnknownError, 0);
 }
 
 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaDrmBridge_getMediaCrypto(env, j_media_drm_.obj());
 }
 
 // static
 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
   return MediaDrmBridge::SECURITY_LEVEL_1 == security_level;
@@ skipping 28 matching lines @@
 uint32_t MediaDrmBridge::DetermineReferenceId(const std::string& session_id) {
   for (SessionMap::iterator it = session_map_.begin();
        it != session_map_.end();
        ++it) {
     if (it->second == session_id)
       return it->first;
   }
 
   // There is no entry in the map; assume it came from the oldest
   // GenerateKeyRequest() call.
-  DCHECK(!pending_key_request_reference_ids_.empty());
-  uint32 reference_id = pending_key_request_reference_ids_.front();
-  pending_key_request_reference_ids_.pop();
+  DCHECK(!pending_key_request_session_ids_.empty());
+  uint32 session_reference_id = pending_key_request_session_ids_.front();
+  pending_key_request_session_ids_.pop();
 
   // If this is a valid |session_id|, add it to the list. Otherwise, avoid
   // adding empty string as a mapping to prevent future calls with an empty
-  // string from using the wrong reference_id.
+  // string from using the wrong session_reference_id.
   if (!session_id.empty()) {
-    DCHECK(session_map_.find(reference_id) == session_map_.end());
-    DCHECK(!session_id.empty());
-    session_map_[reference_id] = session_id;
+    DCHECK(session_map_.find(session_reference_id) == session_map_.end());
+    session_map_[session_reference_id] = session_id;
   }
 
-  return reference_id;
+  return session_reference_id;
 }
 
-const std::string& MediaDrmBridge::LookupSessionId(uint32 reference_id) {
+const std::string& MediaDrmBridge::LookupSessionId(uint32 session_id) {
   // Session may not exist if error happens during GenerateKeyRequest().
-  SessionMap::iterator it = session_map_.find(reference_id);
+  SessionMap::iterator it = session_map_.find(session_id);
   return (it != session_map_.end()) ? it->second : base::EmptyString();
 }
 
 }  // namespace media