Update MediaKeys interface for EME

content/renderer/media/crypto/proxy_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 "content/renderer/media/crypto/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 200 matching lines @@
 void ProxyDecryptor::CancelKeyRequest(const std::string& web_session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
   scoped_ptr<media::SimpleCdmPromise> promise(
       new media::SimpleCdmPromise(base::Bind(&ProxyDecryptor::OnSessionClosed,
                                              weak_ptr_factory_.GetWeakPtr(),
                                              web_session_id),
                                   base::Bind(&ProxyDecryptor::OnSessionError,
                                              weak_ptr_factory_.GetWeakPtr(),
                                              web_session_id)));
-  media_keys_->ReleaseSession(web_session_id, promise.Pass());
+  media_keys_->RemoveSession(web_session_id, promise.Pass());

[ddorwin, 2014/09/24 17:37:46]

This may not be correct looking at the flow in ToT, which currently goes to
CloseSession in the CDM. We need to discuss.

[jrummell, 2014/09/24 22:32:32]

Prior to https://codereview.chromium.org/496143002 (2 weeks ago)
ReleaseSession() did call RemoveSession().
https://codereview.chromium.org/497153005 (4 weeks ago) description implies that
RemoveSession() is what should be called. No idea why no bugs for this in the
last 2 weeks.

[ddorwin, 2014/09/24 22:47:29]

Confirmed and filed bug 417481, which this CL fixes.

 }
 
 scoped_ptr<media::MediaKeys> ProxyDecryptor::CreateMediaKeys(
     const std::string& key_system,
     const GURL& security_origin) {
   return ContentDecryptionModuleFactory::Create(
       key_system,
       security_origin,
 #if defined(ENABLE_PEPPER_CDMS)
       create_pepper_cdm_cb_,
 #elif defined(ENABLE_BROWSER_CDMS)
       manager_,
       &cdm_id_,
 #endif  // defined(ENABLE_PEPPER_CDMS)
       base::Bind(&ProxyDecryptor::OnSessionMessage,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProxyDecryptor::OnSessionReady,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProxyDecryptor::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ProxyDecryptor::OnSessionError,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&ProxyDecryptor::OnSessionKeysChange,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&ProxyDecryptor::OnSessionExpirationChange,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ProxyDecryptor::OnSessionMessage(const std::string& web_session_id,
                                       const std::vector<uint8>& message,
                                       const GURL& destination_url) {
   // Assumes that OnSessionCreated() has been called before this.
 
   // For ClearKey, convert the message from JSON into just passing the key
   // as the message. If unable to extract the key, return the message unchanged.
   if (is_clear_key_) {
     std::vector<uint8> key;
     if (media::ExtractFirstKeyIdFromLicenseRequest(message, &key)) {
       key_message_cb_.Run(web_session_id, key, destination_url);
       return;
     }
   }
 
   key_message_cb_.Run(web_session_id, message, destination_url);
 }
 
+void ProxyDecryptor::OnSessionKeysChange(const std::string& web_session_id,
+                                         bool has_additional_usable_key) {
+  // EME v0.1b doesn't support this event.
+}
+
+void ProxyDecryptor::OnSessionExpirationChange(
+    const std::string& web_session_id,
+    double new_expiry_time) {
+  // EME v0.1b doesn't support this event.
+}
+
 void ProxyDecryptor::OnSessionReady(const std::string& web_session_id) {
   key_added_cb_.Run(web_session_id);
 }
 
 void ProxyDecryptor::OnSessionClosed(const std::string& web_session_id) {
   base::hash_map<std::string, bool>::iterator it =
       active_sessions_.find(web_session_id);
 
   // Latest EME spec separates closing a session ("allows an application to
   // indicate that it no longer needs the session") and actually closing the
@@ skipping 46 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(web_session_id, is_persistent));
 
   // For LoadSession(), generate the SessionReady event.
   if (session_type == LoadSession)
     OnSessionReady(web_session_id);
 }
 
 }  // namespace content