Properly determine if a new key was added in AesDecryptor::Update()

media/cdm/aes_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 "media/cdm/aes_decryptor.h"
 
 #include <list>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 316 matching lines @@
     return;
   }
 
   // Make sure that at least one key was extracted.
   if (keys.empty()) {
     promise->reject(
         INVALID_ACCESS_ERROR, 0, "Response does not contain any keys.");
     return;
   }
 
+  bool key_added = false;
   for (KeyIdAndKeyPairs::iterator it = keys.begin(); it != keys.end(); ++it) {
     if (it->second.length() !=
         static_cast<size_t>(DecryptConfig::kDecryptionKeySize)) {
       DVLOG(1) << "Invalid key length: " << it->second.length();
       promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid key length.");
       return;
     }
+
+    // If this key_id doesn't currently exist in this session,
+    // a new key is added.
+    if (!HasKey(session_id, it->first))
+      key_added = true;
+
     if (!AddDecryptionKey(session_id, it->first, it->second)) {
       promise->reject(INVALID_ACCESS_ERROR, 0, "Unable to add key.");
       return;
     }
   }
 
   {
     base::AutoLock auto_lock(new_key_cb_lock_);
 
     if (!new_audio_key_cb_.is_null())
@@ skipping 13 matching lines @@
       if (item.second->Contains(session_id)) {
         scoped_ptr<CdmKeyInformation> key_info(new CdmKeyInformation);
         key_info->key_id.assign(item.first.begin(), item.first.end());
         key_info->status = CdmKeyInformation::USABLE;
         key_info->system_code = 0;
         keys_info.push_back(key_info.release());
       }
     }
   }
 
-  // Assume that at least 1 new key has been successfully added and thus
-  // sending true for |has_additional_usable_key|. http://crbug.com/448219.
-  session_keys_change_cb_.Run(session_id, true, keys_info.Pass());
+  session_keys_change_cb_.Run(session_id, key_added, keys_info.Pass());
 }
 
 void AesDecryptor::CloseSession(const std::string& session_id,
                                 scoped_ptr<SimpleCdmPromise> promise) {
   // Validate that this is a reference to an active session and then forget it.
   std::set<std::string>::iterator it = valid_sessions_.find(session_id);
   DCHECK(it != valid_sessions_.end());
 
   valid_sessions_.erase(it);
 
@@ skipping 149 matching lines @@
     const std::string& key_id) const {
   base::AutoLock auto_lock(key_map_lock_);
   KeyIdToSessionKeysMap::const_iterator key_id_found = key_map_.find(key_id);
   if (key_id_found == key_map_.end())
     return NULL;
 
   // Return the key from the "latest" session_id entry.
   return key_id_found->second->LatestDecryptionKey();
 }
 
+bool AesDecryptor::HasKey(const std::string& session_id,
+                          const std::string& key_id) {
+  base::AutoLock auto_lock(key_map_lock_);
+  KeyIdToSessionKeysMap::const_iterator key_id_found = key_map_.find(key_id);
+  if (key_id_found == key_map_.end())
+    return false;
+
+  return key_id_found->second->Contains(session_id);
+}
+
 void AesDecryptor::DeleteKeysForSession(const std::string& session_id) {
   base::AutoLock auto_lock(key_map_lock_);
 
   // Remove all keys associated with |session_id|. Since the data is
   // optimized for access in GetKey(), we need to look at each entry in
   // |key_map_|.
   KeyIdToSessionKeysMap::iterator it = key_map_.begin();
   while (it != key_map_.end()) {
     it->second->Erase(session_id);
     if (it->second->Empty()) {
@@ skipping 17 matching lines @@
 bool AesDecryptor::DecryptionKey::Init() {
   CHECK(!secret_.empty());
   decryption_key_.reset(crypto::SymmetricKey::Import(
       crypto::SymmetricKey::AES, secret_));
   if (!decryption_key_)
     return false;
   return true;
 }
 
 }  // namespace media