Update MediaKeys interface for EME

media/cdm/ppapi/external_clear_key/clear_key_cdm.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/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <string>
@@ skipping 202 matching lines @@
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host, const std::string& key_system)
     : decryptor_(
-        base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
-        base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this))),
+          base::Bind(&ClearKeyCdm::OnSessionMessage, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionClosed, base::Unretained(this)),
+          base::Bind(&ClearKeyCdm::OnSessionKeysChange,
+                     base::Unretained(this))),
       host_(host),
       key_system_(key_system),
       timer_delay_ms_(kInitialTimerDelayMs),
       heartbeat_timer_set_(false) {
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
   total_samples_generated_ = 0;
@@ skipping 85 matching lines @@
   }
 }
 
 void ClearKeyCdm::CloseSession(uint32 promise_id,
                                const char* web_session_id,
                                uint32_t web_session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(web_session_id, web_session_id_length);
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::SimpleCdmPromise(
-      base::Bind(&ClearKeyCdm::OnSessionReleased,
-                 base::Unretained(this),
-                 promise_id,
-                 web_session_str),
+      base::Bind(
+          &ClearKeyCdm::OnPromiseResolved, base::Unretained(this), promise_id),
       base::Bind(
           &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
-  decryptor_.ReleaseSession(web_session_str, promise.Pass());
+  decryptor_.CloseSession(web_session_str, promise.Pass());
 }
 
 void ClearKeyCdm::RemoveSession(uint32 promise_id,
                                 const char* web_session_id,
                                 uint32_t web_session_id_length) {
   DVLOG(1) << __FUNCTION__;
   // RemoveSession only allowed for persistent sessions.
   bool is_persistent_session =
       std::string(kLoadableWebSessionId) ==
       std::string(web_session_id, web_session_id_length);
   if (is_persistent_session) {
-    host_->OnResolvePromise(promise_id);
+    std::string web_session_str(web_session_id, web_session_id_length);
+
+    scoped_ptr<media::SimpleCdmPromise> promise(
+        new media::SimpleCdmPromise(base::Bind(&ClearKeyCdm::OnPromiseResolved,
+                                               base::Unretained(this),
+                                               promise_id),
+                                    base::Bind(&ClearKeyCdm::OnPromiseFailed,
+                                               base::Unretained(this),
+                                               promise_id)));
+    decryptor_.RemoveSession(web_session_str, promise.Pass());

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

We're implementing persistent session support on a decryptor that does not
support it. I think we will need to call CloseSession() in the future. Maybe a
TODO just so we don't forget this discussion.

Before we didn't even call the decryptor_ - I'm not sure how that worked.

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

The problem with calling close() is that it will reject the promise if the
session is already closed. Since aes_decryptor doesn't support persistent
session, I have it close the session if it exists, but it always resolves the
promise successfully.

   } else {
     std::string message("Not supported for non-persistent sessions.");
     host_->OnRejectPromise(promise_id,

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

This should be a DCHECK once session type is moved up.

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

Done.

                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
   }
 }
 
 void ClearKeyCdm::SetServerCertificate(uint32 promise_id,
                                        const uint8_t* server_certificate_data,
                                        uint32_t server_certificate_data_size) {
@@ skipping 314 matching lines @@
   // involved (OnSessionCreated() called to resolve the CreateSession()
   // promise).
   host_->OnSessionMessage(web_session_id.data(),
                           web_session_id.length(),
                           reinterpret_cast<const char*>(message.data()),
                           message.size(),
                           destination_url.spec().data(),
                           destination_url.spec().size());
 }
 
+void ClearKeyCdm::OnSessionKeysChange(const std::string& web_session_id,
+                                      bool has_additional_usable_key) {
+  host_->OnSessionUsableKeysChange(web_session_id.data(),
+                                   web_session_id.length(),
+                                   has_additional_usable_key);
+}
+
 void ClearKeyCdm::OnSessionClosed(const std::string& web_session_id) {
   host_->OnSessionClosed(web_session_id.data(), web_session_id.length());
 }
 
 void ClearKeyCdm::OnSessionCreated(uint32 promise_id,
                                    const std::string& web_session_id) {
   // Save the latest session ID for heartbeat and file IO test messages.
   last_session_id_ = web_session_id;
 
   host_->OnResolveNewSessionPromise(
@@ skipping 30 matching lines @@
     session_id_for_emulated_loadsession_ = std::string();
     // |promise_id| is the LoadSession() promise, so resolve appropriately.
     host_->OnResolveNewSessionPromise(
         promise_id, kLoadableWebSessionId, strlen(kLoadableWebSessionId));
     return;
   }
 
   host_->OnResolvePromise(promise_id);
 }
 
-void ClearKeyCdm::OnSessionReleased(uint32 promise_id,
-                                    const std::string& web_session_id) {
-  host_->OnResolvePromise(promise_id);
-}
-
 void ClearKeyCdm::OnUsableKeyIdsObtained(uint32 promise_id,
                                          const KeyIdsVector& key_ids) {
   scoped_ptr<cdm::BinaryData[]> result(new cdm::BinaryData[key_ids.size()]);
   for (uint32 i = 0; i < key_ids.size(); ++i) {
     result[i].data = key_ids[i].data();
     result[i].length = key_ids[i].size();
   }
   host_->OnResolveKeyIdsPromise(promise_id, result.get(), key_ids.size());
 }
 
+void ClearKeyCdm::OnPromiseResolved(uint32 promise_id) {
+  host_->OnResolvePromise(promise_id);
+}
+
 void ClearKeyCdm::OnPromiseFailed(uint32 promise_id,
                                   MediaKeys::Exception exception_code,
                                   uint32 system_code,
                                   const std::string& error_message) {
   host_->OnRejectPromise(promise_id,
                          ConvertException(exception_code),
                          system_code,
                          error_message.data(),
                          error_message.length());
 }
@@ skipping 70 matching lines @@
   host_->OnSessionMessage(last_session_id_.data(),
                           last_session_id_.length(),
                           message.data(),
                           message.length(),
                           NULL,
                           0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media