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) {
+  // AesDecryptor does not communicate with a license server, so no need to
+  // handle the server certificate. Simply resolve the promise.
+  promise->resolve();

[ddorwin, 2014/09/12 21:46:30]

Reject with not supported. CK key system does not support this.
https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-...

[jrummell, 2014/09/15 18:22:40]

Done.

+}
+
 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();
+
+  // Keys have been added, so send notification.
+  session_keys_change_cb_.Run(web_session_id, true);

[ddorwin, 2014/09/12 21:46:30]

We should at least comment that we are assuming key(s) have been added and thus
sending true. (Ideally, we would check, but it's probably not worth the effort.)

[jrummell, 2014/09/15 18:22:40]

Done.

 }
 
-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) {
+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.

[ddorwin, 2014/09/12 21:46:30]

Since this either comes from line 360 or unprefixed, it must always be valid.
Thus, we can DCHECK like 371.

[jrummell, 2014/09/15 18:22:40]

Done.

   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);
 }
 
+void AesDecryptor::RemoveSession(const std::string& web_session_id,
+                                 scoped_ptr<SimpleCdmPromise> promise) {
+  // AesDecryptor doesn't keep any persistent data, so no work to do.

[ddorwin, 2014/09/12 21:46:30]

This should be rejected: Step 2 of
https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-...

Really, we should reject at a higher level and NOTREACHED() here. Maybe file a
bug or update the "implement session types" bug and reference it here in a TODO
that says to NOTREACHED() here.

EXCEPT: We need this for ProxyDecryptor::CancelKeyRequest(). :(
So, add "and prefixed is removed" to the TODO.

[jrummell, 2014/09/15 18:22:40]

Done.

+  // However, close the session if it exists.
+  if (valid_sessions_.find(web_session_id) != valid_sessions_.end()) {
+    CloseSession(web_session_id, promise.Pass());
+    return;
+  }
+
+  promise->resolve();

[ddorwin, 2014/09/12 21:46:30]

If it's not found (only prefixed case), we should reject.

[jrummell, 2014/09/15 18:22:40]

Done.

+}
+
+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);
+}
+
 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