Update MediaKeys interface for EME

content/renderer/media/crypto/proxy_media_keys.cc

 // Copyright 2014 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 "content/renderer/media/crypto/proxy_media_keys.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 30 matching lines @@
   // Reject any outstanding promises.
   for (PromiseMap::iterator it = session_id_to_promise_map_.begin();
        it != session_id_to_promise_map_.end();
        ++it) {
     it->second->reject(
         media::MediaKeys::NOT_SUPPORTED_ERROR, 0, "The operation was aborted.");
   }
   session_id_to_promise_map_.clear();
 }
 
+void ProxyMediaKeys::SetServerCertificate(
+    const uint8* certificate_data,
+    int certificate_data_length,
+    scoped_ptr<media::SimpleCdmPromise> promise) {
+  promise->reject(
+      INVALID_ACCESS_ERROR, 0, "SetServerCertificate() is not supported.");

[ddorwin, 2014/09/10 22:58:38]

There is a NOT_SUPPORTED_ERROR.
Note: Eventually, the Android implementation should accept and use this.

[jrummell, 2014/09/11 21:21:54]

Done.

+}
+
 void ProxyMediaKeys::CreateSession(
     const std::string& init_data_type,
     const uint8* init_data,
     int init_data_length,
     SessionType session_type,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
   // TODO(xhwang): Move these checks up to blink and DCHECK here.
   // See http://crbug.com/342510
   CdmHostMsg_CreateSession_ContentType create_session_content_type;
   if (init_data_type == "cenc") {
@@ skipping 39 matching lines @@
     return;
   }
 
   SavePromise(session_id, promise.PassAs<media::CdmPromise>());
   manager_->UpdateSession(
       cdm_id_,
       session_id,
       std::vector<uint8>(response, response + response_length));
 }
 
-void ProxyMediaKeys::ReleaseSession(
+void ProxyMediaKeys::CloseSession(const std::string& web_session_id,
+                                  scoped_ptr<media::SimpleCdmPromise> promise) {
+  promise->reject(INVALID_ACCESS_ERROR, 0, "CloseSession() is not supported.");

[ddorwin, 2014/09/10 22:58:38]

ditto on NOT_SUPPORTED_ERROR. The comment should be something like "Not yet
implemented."

[jrummell, 2014/09/11 21:21:54]

See comment below.

+}
+
+void ProxyMediaKeys::RemoveSession(
     const std::string& web_session_id,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   uint32 session_id = LookupSessionId(web_session_id);
   if (!session_id) {
     promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
     return;
   }
 
   SavePromise(session_id, promise.PassAs<media::CdmPromise>());
   manager_->ReleaseSession(cdm_id_, session_id);

[ddorwin, 2014/09/10 22:58:38]

Which function should actually be calling this? On Android, it seems more like
Close() - I don't think we have any uses of CKR on Android.

[jrummell, 2014/09/11 21:21:54]

Since v0.1b CKR calls turn into RemoveSession() currently, I was doing it this
way to match existing code. Changed so both methods call ReleaseSession().
Unprefixed EME will let close() work, and remove() will fail (with session not
found), which makes sense since LoadSession() is not supported, so no persistent
data. Prefixed EME calls (which call RemoveSession()) will work as well.

[ddorwin, 2014/09/11 23:31:11]

See comment in new PS.

 }
 
+void ProxyMediaKeys::GetUsableKeyIds(const std::string& web_session_id,
+                                     scoped_ptr<media::KeyIdsPromise> promise) {
+  promise->reject(
+      INVALID_ACCESS_ERROR, 0, "GetUsableKeyIds() is not supported.");

[ddorwin, 2014/09/10 22:58:38]

ditto

[jrummell, 2014/09/11 21:21:54]

Done.

+}
+
 void ProxyMediaKeys::OnSessionCreated(uint32 session_id,
                                       const std::string& web_session_id) {
   AssignWebSessionId(session_id, web_session_id);
   scoped_ptr<media::CdmPromise> promise = TakePromise(session_id);
   if (promise) {
     media::NewSessionCdmPromise* session_promise(
         static_cast<media::NewSessionCdmPromise*>(promise.get()));
     session_promise->resolve(web_session_id);
   }
 }
@@ skipping 131 matching lines @@
 
 scoped_ptr<media::CdmPromise> ProxyMediaKeys::TakePromise(uint32_t session_id) {
   PromiseMap::iterator it = session_id_to_promise_map_.find(session_id);
   // May not be a promise associated with this session for asynchronous events.
   if (it == session_id_to_promise_map_.end())
     return scoped_ptr<media::CdmPromise>();
   return session_id_to_promise_map_.take_and_erase(it);
 }
 
 }  // namespace content