Prefixed EME: Fire special KeyError when a persistent session is closed.

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"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/crypto/content_decryption_module_factory.h"
 #if defined(OS_ANDROID)
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #endif  // defined(OS_ANDROID)
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
 namespace content {
 
 // Since these reference IDs may conflict with the ones generated in
 // WebContentDecryptionModuleSessionImpl for the short time both paths are
 // active, start with 100000 and generate the IDs from there.
 // TODO(jrummell): Only allow one path http://crbug.com/306680.
 uint32 ProxyDecryptor::next_session_id_ = 100000;
 
 const uint32 kInvalidSessionId = 0;
 
+// Special system code to signal a closed persistent session in a SessionError()
+// call. This is needed because there is no SessionClosed() call in the prefixed
+// EME API.
+const int kSessionClosedSystemCode = 7 * 1024 * 1024 + 7;
+
 #if defined(ENABLE_PEPPER_CDMS)
 void ProxyDecryptor::DestroyHelperPlugin() {
   ContentDecryptionModuleFactory::DestroyHelperPlugin(
       web_media_player_client_, web_frame_);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 ProxyDecryptor::ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
     blink::WebMediaPlayerClient* web_media_player_client,
@@ skipping 38 matching lines @@
   DCHECK(!media_keys_);
   media_keys_ = CreateMediaKeys(key_system, frame_url);
   if (!media_keys_)
     return false;
 
   is_clear_key_ =
       media::IsClearKey(key_system) || media::IsExternalClearKey(key_system);
   return true;
 }
 
+// Returns true if |data| is prefixed with |header| and has data after the
+// |header|.
+bool HasHeader(const uint8* data, int data_length, const std::string& header) {
+  return static_cast<size_t>(data_length) > header.size() &&
+         std::equal(data, data + header.size(), header.begin());
+}
+
 bool ProxyDecryptor::GenerateKeyRequest(const std::string& content_type,
                                         const uint8* init_data,
                                         int init_data_length) {
   // Use a unique reference id for this request.
   uint32 session_id = next_session_id_++;
 
-  const uint8 kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
-  const int kPrefixedApiLoadSessionHeaderLength =
-      sizeof(kPrefixedApiLoadSessionHeader) - 1;
+  const char kPrefixedApiPersistentSessionHeader[] = "PERSISTENT|";
+  const char kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
 
-  if (init_data_length > kPrefixedApiLoadSessionHeaderLength &&
-      std::equal(init_data,
-                 init_data + kPrefixedApiLoadSessionHeaderLength,
-                 kPrefixedApiLoadSessionHeader)) {
-    // TODO(xhwang): Track loadable session to handle OnSessionClosed().
-    // See: http://crbug.com/340859.
+  if (HasHeader(init_data, init_data_length, kPrefixedApiLoadSessionHeader)) {
+    persistent_sessions_.insert(session_id);
     media_keys_->LoadSession(
         session_id,
         std::string(reinterpret_cast<const char*>(
-                        init_data + kPrefixedApiLoadSessionHeaderLength),
-                    init_data_length - kPrefixedApiLoadSessionHeaderLength));
+                        init_data + strlen(kPrefixedApiLoadSessionHeader)),
+                    init_data_length - strlen(kPrefixedApiLoadSessionHeader)));
     return true;
   }
 
+  if (HasHeader(
+          init_data, init_data_length, kPrefixedApiPersistentSessionHeader))
+    persistent_sessions_.insert(session_id);
+
   return media_keys_->CreateSession(
       session_id, content_type, init_data, init_data_length);
 }
 
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& web_session_id) {
   DVLOG(1) << "AddKey()";
@@ skipping 92 matching lines @@
   // Assumes that OnSessionCreated() has been called before this.
   key_message_cb_.Run(LookupWebSessionId(session_id), message, destination_url);
 }
 
 void ProxyDecryptor::OnSessionReady(uint32 session_id) {
   // Assumes that OnSessionCreated() has been called before this.
   key_added_cb_.Run(LookupWebSessionId(session_id));
 }
 
 void ProxyDecryptor::OnSessionClosed(uint32 session_id) {
-  // No closed event in EME v0.1b.
+  std::set<uint32>::iterator it = persistent_sessions_.find(session_id);
+  if (it != persistent_sessions_.end()) {
+    persistent_sessions_.erase(it);
+    OnSessionError(
+        session_id, media::MediaKeys::kUnknownError, kSessionClosedSystemCode);
+  }
+
+  sessions_.erase(session_id);
 }
 
 void ProxyDecryptor::OnSessionError(uint32 session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   // Assumes that OnSessionCreated() has been called before this.
   key_error_cb_.Run(LookupWebSessionId(session_id), error_code, system_code);
 }
 
 uint32 ProxyDecryptor::LookupSessionId(const std::string& session_id) const {
@@ skipping 13 matching lines @@
 
 const std::string& ProxyDecryptor::LookupWebSessionId(uint32 session_id) const {
   DCHECK_NE(session_id, kInvalidSessionId);
 
   // Session may not exist if error happens during GenerateKeyRequest().
   SessionIdMap::const_iterator it = sessions_.find(session_id);
   return (it != sessions_.end()) ? it->second : base::EmptyString();
 }
 
 }  // namespace content