Update MediaKeys interface for EME

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 206 matching lines @@
 
   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 SessionMessageCB& session_message_cb,
-                           const SessionClosedCB& session_closed_cb)
+                           const SessionClosedCB& session_closed_cb,
+                           const SessionKeysChangeCB& session_keys_change_cb)
     : session_message_cb_(session_message_cb),
-      session_closed_cb_(session_closed_cb) {
+      session_closed_cb_(session_closed_cb),
+      session_keys_change_cb_(session_keys_change_cb) {
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
+  DCHECK(!session_keys_change_cb_.is_null());
 }
 
 AesDecryptor::~AesDecryptor() {
   key_map_.clear();
 }
 
+void AesDecryptor::SetServerCertificate(const uint8* certificate_data,
+                                        int certificate_data_length,
+                                        scoped_ptr<SimpleCdmPromise> promise) {
+  promise->reject(
+      NOT_SUPPORTED_ERROR, 0, "SetServerCertificate() is not supported.");
+}
+
 void AesDecryptor::CreateSession(const std::string& init_data_type,
                                  const uint8* init_data,
                                  int init_data_length,
                                  SessionType session_type,
                                  scoped_ptr<NewSessionCdmPromise> promise) {
   std::string web_session_id(base::UintToString(next_web_session_id_++));
   valid_sessions_.insert(web_session_id);
 
   // For now, the AesDecryptor does not care about |init_data_type| or
   // |session_type|; just resolve the promise and then fire a message event
@@ skipping 63 matching lines @@
     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();
   }
 
   promise->resolve();
+
+  // Assume that at least 1 new key has been successfully added and thus
+  // sending true.
+  session_keys_change_cb_.Run(web_session_id, true);
+}
+
+void AesDecryptor::CloseSession(const std::string& web_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(web_session_id);
+  DCHECK(it != valid_sessions_.end());
+
+  valid_sessions_.erase(it);
+
+  // Close the session.
+  DeleteKeysForSession(web_session_id);
+  promise->resolve();
+  session_closed_cb_.Run(web_session_id);
+}
+
+void AesDecryptor::RemoveSession(const std::string& web_session_id,
+                                 scoped_ptr<SimpleCdmPromise> promise) {
+  // AesDecryptor doesn't keep any persistent data, so this should be
+  // NOT_REACHED().
+  // TODO(jrummell): Make sure persistent session types are rejected.
+  // http://crbug.com/384152.
+  //
+  // However, v0.1b calls to CancelKeyRequest() will call this, so close the
+  // session, if it exists.
+  // TODO(jrummell): Remove the close() call when prefixed EME is removed.
+  // http://crbug.com/249976.
+  if (valid_sessions_.find(web_session_id) != valid_sessions_.end()) {
+    CloseSession(web_session_id, promise.Pass());
+    return;
+  }
+
+  promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
 }
 
 void AesDecryptor::GetUsableKeyIds(const std::string& web_session_id,
                                    scoped_ptr<KeyIdsPromise> promise) {
   // Since |web_session_id| is not provided by the user, this should never
   // happen.
   DCHECK(valid_sessions_.find(web_session_id) != valid_sessions_.end());
 
   KeyIdsVector keyids;
   base::AutoLock auto_lock(key_map_lock_);
   for (KeyIdToSessionKeysMap::iterator it = key_map_.begin();
        it != key_map_.end();
        ++it) {
     if (it->second->Contains(web_session_id))
       keyids.push_back(std::vector<uint8>(it->first.begin(), it->first.end()));
   }
   promise->resolve(keyids);
 }
 
-void AesDecryptor::ReleaseSession(const std::string& web_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(web_session_id);
-  // TODO(jrummell): Convert back to a DCHECK once prefixed EME is removed.
-  if (it == valid_sessions_.end()) {
-    promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
-    return;
-  }
-
-  valid_sessions_.erase(it);
-
-  // Close the session.
-  DeleteKeysForSession(web_session_id);
-  promise->resolve();
-  session_closed_cb_.Run(web_session_id);
-}
-
 Decryptor* AesDecryptor::GetDecryptor() {
   return this;
 }
 
 void AesDecryptor::RegisterNewKeyCB(StreamType stream_type,
                                     const NewKeyCB& new_key_cb) {
   base::AutoLock auto_lock(new_key_cb_lock_);
 
   switch (stream_type) {
     case kAudio:
@@ skipping 141 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