Add Promises for EME (Chromium side)

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"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
+#include "media/base/media_keys_session_promise.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/cdm/json_web_key.h"
 
 namespace media {
 
 // Keeps track of the session IDs and DecryptionKeys. The keys are ordered by
 // insertion time (last insertion is first). It takes ownership of the
 // DecryptionKeys.
 class AesDecryptor::SessionIdDecryptionKeyMap {
   // Use a std::list to actually hold the data. Insertion is always done
   // at the front, so the "latest" decryption key is always the first one
   // in the list.
-  typedef std::list<std::pair<uint32, DecryptionKey*> > KeyList;
+  typedef std::list<std::pair<std::string, DecryptionKey*> > KeyList;
 
  public:
   SessionIdDecryptionKeyMap() {}
   ~SessionIdDecryptionKeyMap() { STLDeleteValues(&key_list_); }
 
   // Replaces value if |session_id| is already present, or adds it if not.
   // This |decryption_key| becomes the latest until another insertion or
   // |session_id| is erased.
-  void Insert(uint32 session_id, scoped_ptr<DecryptionKey> decryption_key);
+  void Insert(const std::string& web_session_id,
+              scoped_ptr<DecryptionKey> decryption_key);
 
   // Deletes the entry for |session_id| if present.
-  void Erase(const uint32 session_id);
+  void Erase(const std::string& web_session_id);
 
   // Returns whether the list is empty
   bool Empty() const { return key_list_.empty(); }
 
   // Returns the last inserted DecryptionKey.
   DecryptionKey* LatestDecryptionKey() {
     DCHECK(!key_list_.empty());
     return key_list_.begin()->second;
   }
 
  private:
-  // Searches the list for an element with |session_id|.
-  KeyList::iterator Find(const uint32 session_id);
+  // Searches the list for an element with |web_session_id|.
+  KeyList::iterator Find(const std::string& web_session_id);
 
   // Deletes the entry pointed to by |position|.
   void Erase(KeyList::iterator position);
 
   KeyList key_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionIdDecryptionKeyMap);
 };
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Insert(
-    uint32 session_id,
+    const std::string& web_session_id,
     scoped_ptr<DecryptionKey> decryption_key) {
-  KeyList::iterator it = Find(session_id);
+  KeyList::iterator it = Find(web_session_id);
   if (it != key_list_.end())
     Erase(it);
   DecryptionKey* raw_ptr = decryption_key.release();
-  key_list_.push_front(std::make_pair(session_id, raw_ptr));
+  key_list_.push_front(std::make_pair(web_session_id, raw_ptr));
 }
 
-void AesDecryptor::SessionIdDecryptionKeyMap::Erase(const uint32 session_id) {
-  KeyList::iterator it = Find(session_id);
+void AesDecryptor::SessionIdDecryptionKeyMap::Erase(
+    const std::string& web_session_id) {
+  KeyList::iterator it = Find(web_session_id);
   if (it == key_list_.end())
     return;
   Erase(it);
 }
 
 AesDecryptor::SessionIdDecryptionKeyMap::KeyList::iterator
-AesDecryptor::SessionIdDecryptionKeyMap::Find(const uint32 session_id) {
+AesDecryptor::SessionIdDecryptionKeyMap::Find(
+    const std::string& web_session_id) {
   for (KeyList::iterator it = key_list_.begin(); it != key_list_.end(); ++it) {
-    if (it->first == session_id)
+    if (it->first == web_session_id)
       return it;
   }
   return key_list_.end();
 }
 
 void AesDecryptor::SessionIdDecryptionKeyMap::Erase(
     KeyList::iterator position) {
   DCHECK(position->second);
   delete position->second;
   key_list_.erase(position);
@@ skipping 111 matching lines @@
   DCHECK_EQ(decrypted_text.size(), encrypted_text.size());
 
   scoped_refptr<DecoderBuffer> output = DecoderBuffer::CopyFrom(
       reinterpret_cast<const uint8*>(sample), sample_size);
   CopySubsamples(subsamples, kDstContainsClearBytes,
                  reinterpret_cast<const uint8*>(decrypted_text.data()),
                  output->writable_data());
   return output;
 }
 
-AesDecryptor::AesDecryptor(const SessionCreatedCB& session_created_cb,
-                           const SessionMessageCB& session_message_cb,
-                           const SessionReadyCB& session_ready_cb,
-                           const SessionClosedCB& session_closed_cb,
-                           const SessionErrorCB& session_error_cb)
-    : session_created_cb_(session_created_cb),
-      session_message_cb_(session_message_cb),
-      session_ready_cb_(session_ready_cb),
-      session_closed_cb_(session_closed_cb),
-      session_error_cb_(session_error_cb) {}
+AesDecryptor::AesDecryptor(const SessionMessageCB& session_message_cb)
+    : session_message_cb_(session_message_cb) {
+  DCHECK(!session_message_cb_.is_null());
+}
 
 AesDecryptor::~AesDecryptor() {
   key_map_.clear();
 }
 
-bool AesDecryptor::CreateSession(uint32 session_id,
-                                 const std::string& content_type,
+void AesDecryptor::CreateSession(const std::string& init_data_type,
                                  const uint8* init_data,
-                                 int init_data_length) {
-  // Validate that this is a new session.
-  DCHECK(valid_sessions_.find(session_id) == valid_sessions_.end());
-  valid_sessions_.insert(session_id);
+                                 int init_data_length,
+                                 SessionType session_type,
+                                 scoped_ptr<MediaKeysSessionPromise> promise) {
+  std::string web_session_id(base::UintToString(next_web_session_id_++));
+  valid_sessions_.insert(web_session_id);
 
-  std::string web_session_id_string(base::UintToString(next_web_session_id_++));
-
-  // For now, the AesDecryptor does not care about |content_type|;
-  // just fire the event with the |init_data| as the request.
+  // For now, the AesDecryptor does not care about |init_data_type| or
+  // |session_type|; just resolve the promise and then fire a message event
+  // with the |init_data| as the request.
   std::vector<uint8> message;
   if (init_data && init_data_length)
     message.assign(init_data, init_data + init_data_length);
 
-  session_created_cb_.Run(session_id, web_session_id_string);
-  session_message_cb_.Run(session_id, message, std::string());
-  return true;
+  promise->resolve(web_session_id);
+  promise.reset();
+
+  session_message_cb_.Run(web_session_id, message, std::string());
 }
 
-void AesDecryptor::LoadSession(uint32 session_id,
-                               const std::string& web_session_id) {
+void AesDecryptor::LoadSession(const std::string& web_session_id,
+                               scoped_ptr<MediaKeysSessionPromise> promise) {
   // TODO(xhwang): Change this to NOTREACHED() when blink checks for key systems
   // that do not support loadSession. See http://crbug.com/342481
-  session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
+  promise->reject("NotSupportedError", 0, "LoadSession() is not implemented.");
+  promise.reset();
 }
 
-void AesDecryptor::UpdateSession(uint32 session_id,
+void AesDecryptor::UpdateSession(const std::string& web_session_id,
                                  const uint8* response,
-                                 int response_length) {
+                                 int response_length,
+                                 scoped_ptr<MediaKeysSessionPromise> promise) {
   CHECK(response);
   CHECK_GT(response_length, 0);
-  DCHECK(valid_sessions_.find(session_id) != valid_sessions_.end());
+
+  if (valid_sessions_.find(web_session_id) == valid_sessions_.end()) {
+    promise->reject("InvalidStateError", 0, "Session does not exist.");
+    promise.reset();

[xhwang, 2014/05/05 20:46:42]

The |promise| will go out of scope automatically, so no need to reset().

[jrummell, 2014/05/08 23:37:45]

Done.

+    return;
+  }
 
   std::string key_string(reinterpret_cast<const char*>(response),
                          response_length);
+
   KeyIdAndKeyPairs keys;
   if (!ExtractKeysFromJWKSet(key_string, &keys)) {
-    session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
+    promise->reject(
+        "EncodingError", 0, "response is not a valid JSON Web Key Set.");
+    promise.reset();
     return;
   }
 
   // Make sure that at least one key was extracted.
   if (keys.empty()) {
-    session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
+    promise->reject("SyntaxError", 0, "response does not contain any keys.");
+    promise.reset();
     return;
   }
 
   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: " << key_string.length();
-      session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
+      promise->reject("SyntaxError", 0, "Invalid key length.");
+      promise.reset();
       return;
     }
-    if (!AddDecryptionKey(session_id, it->first, it->second)) {
-      session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
+    if (!AddDecryptionKey(web_session_id, it->first, it->second)) {
+      promise->reject("InvalidModificationError", 0, "Unable to add key.");
+      promise.reset();
       return;
     }
   }
 
   {
     base::AutoLock auto_lock(new_key_cb_lock_);
 
     if (!new_audio_key_cb_.is_null())
       new_audio_key_cb_.Run();
 
     if (!new_video_key_cb_.is_null())
       new_video_key_cb_.Run();
   }
 
-  session_ready_cb_.Run(session_id);
+  promise->resolve();
+  promise.reset();
 }
 
-void AesDecryptor::ReleaseSession(uint32 session_id) {
+void AesDecryptor::ReleaseSession(const std::string& web_session_id,
+                                  scoped_ptr<MediaKeysSessionPromise> promise) {
   // Validate that this is a reference to an active session and then forget it.
-  std::set<uint32>::iterator it = valid_sessions_.find(session_id);
-  DCHECK(it != valid_sessions_.end());
+  std::set<std::string>::iterator it = valid_sessions_.find(web_session_id);
+  if (it == valid_sessions_.end()) {
+    promise->reject("InvalidStateError", 0, "Session does not exist.");
+    promise.reset();
+    return;
+  }
+
   valid_sessions_.erase(it);
 
-  DeleteKeysForSession(session_id);
-  session_closed_cb_.Run(session_id);
+  DeleteKeysForSession(web_session_id);
+  promise->resolve();
+  promise.reset();
 }
 
 Decryptor* AesDecryptor::GetDecryptor() {
   return this;
 }
 
 void AesDecryptor::RegisterNewKeyCB(StreamType stream_type,
                                     const NewKeyCB& new_key_cb) {
   base::AutoLock auto_lock(new_key_cb_lock_);
 
@@ skipping 71 matching lines @@
 }
 
 void AesDecryptor::ResetDecoder(StreamType stream_type) {
   NOTREACHED() << "AesDecryptor does not support audio/video decoding";
 }
 
 void AesDecryptor::DeinitializeDecoder(StreamType stream_type) {
   NOTREACHED() << "AesDecryptor does not support audio/video decoding";
 }
 
-bool AesDecryptor::AddDecryptionKey(const uint32 session_id,
+bool AesDecryptor::AddDecryptionKey(const std::string& web_session_id,
                                     const std::string& key_id,
                                     const std::string& key_string) {
   scoped_ptr<DecryptionKey> decryption_key(new DecryptionKey(key_string));
   if (!decryption_key) {
     DVLOG(1) << "Could not create key.";
     return false;
   }
 
   if (!decryption_key->Init()) {
     DVLOG(1) << "Could not initialize decryption key.";
     return false;
   }
 
   base::AutoLock auto_lock(key_map_lock_);
   KeyIdToSessionKeysMap::iterator key_id_entry = key_map_.find(key_id);
   if (key_id_entry != key_map_.end()) {
-    key_id_entry->second->Insert(session_id, decryption_key.Pass());
+    key_id_entry->second->Insert(web_session_id, decryption_key.Pass());
     return true;
   }
 
   // |key_id| not found, so need to create new entry.
   scoped_ptr<SessionIdDecryptionKeyMap> inner_map(
       new SessionIdDecryptionKeyMap());
-  inner_map->Insert(session_id, decryption_key.Pass());
+  inner_map->Insert(web_session_id, decryption_key.Pass());
   key_map_.add(key_id, inner_map.Pass());
   return true;
 }
 
 AesDecryptor::DecryptionKey* AesDecryptor::GetKey(
     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();
 }
 
-void AesDecryptor::DeleteKeysForSession(const uint32 session_id) {
+void AesDecryptor::DeleteKeysForSession(const std::string& web_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_|.
+  // Remove all keys associated with |web_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);
+    it->second->Erase(web_session_id);
     if (it->second->Empty()) {
       // Need to get rid of the entry for this key_id. This will mess up the
       // iterator, so we need to increment it first.
       KeyIdToSessionKeysMap::iterator current = it;
       ++it;
       key_map_.erase(current);
     } else {
       ++it;
     }
   }
 }
 
 AesDecryptor::DecryptionKey::DecryptionKey(const std::string& secret)
     : secret_(secret) {
 }
 
 AesDecryptor::DecryptionKey::~DecryptionKey() {}
 
 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