Implement "Key Presence" step in "Encrypted Block Encounted" algorithm in EME.

webkit/media/crypto/proxy_decryptor.cc

 // Copyright (c) 2012 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 "webkit/media/crypto/proxy_decryptor.h"
 
+#include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
+#include "base/message_loop_proxy.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
 #include "media/crypto/aes_decryptor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "webkit/media/crypto/key_systems.h"
 #include "webkit/media/crypto/ppapi_decryptor.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 // TODO(xhwang): Put this include after "ppapi_plugin_instance.h" for definition
 // of "uint8_t", which WebMediaPlayer.h uses without including a header for it.
 // See: https://bugs.webkit.org/show_bug.cgi?id=92031
 // Fix include order here when the bug is fixed.
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 
+using media::Decryptor;
+using media::DecoderBuffer;
+
 namespace webkit_media {
 
 static scoped_refptr<webkit::ppapi::PluginInstance> CreatePluginInstance(
     const std::string& plugin_type,
     WebKit::WebMediaPlayerClient* web_media_player_client,
     WebKit::WebFrame* web_frame) {
   DCHECK(web_media_player_client);
   DCHECK(web_frame);
 
   WebKit::WebPlugin* web_plugin = web_media_player_client->createHelperPlugin(
       WebKit::WebString::fromUTF8(plugin_type), web_frame);
   if (!web_plugin)
     return NULL;
 
   DCHECK(!web_plugin->isPlaceholder());  // Prevented by WebKit.
   // Only Pepper plugins are supported, so it must be a ppapi object.
   webkit::ppapi::WebPluginImpl* ppapi_plugin =
       static_cast<webkit::ppapi::WebPluginImpl*>(web_plugin);
   return ppapi_plugin->instance();
 }
 
+// TODO(xhwang): Simplify this function. This is mostly caused by the fact that
+// we need to copy a scoped_array<uint8>.
+static void FireNeedKey(media::DecryptorClient* client,
+                        const scoped_refptr<DecoderBuffer>& encrypted) {
+  DCHECK(client);
+  DCHECK(encrypted);
+  DCHECK(encrypted->GetDecryptConfig());
+  const uint8* key_id = encrypted->GetDecryptConfig()->key_id();
+  const int key_id_size = encrypted->GetDecryptConfig()->key_id_size();
+  scoped_array<uint8> key_id_array(new uint8[key_id_size]);
+  memcpy(key_id_array.get(), key_id, key_id_size);
+  client->NeedKey("", "", key_id_array.Pass(), key_id_size);
+}
+
 ProxyDecryptor::ProxyDecryptor(
     media::DecryptorClient* decryptor_client,
     WebKit::WebMediaPlayerClient* web_media_player_client,
     WebKit::WebFrame* web_frame)
     : client_(decryptor_client),
       web_media_player_client_(web_media_player_client),
       web_frame_(web_frame) {
 }
 
 ProxyDecryptor::~ProxyDecryptor() {
 }
 
 void ProxyDecryptor::GenerateKeyRequest(const std::string& key_system,
                                         const uint8* init_data,
                                         int init_data_length) {
   // We do not support run-time switching of decryptors. GenerateKeyRequest()
   // only creates a new decryptor when |decryptor_| is not initialized.
+  DVLOG(1) << "GenerateKeyRequest: key_system = " << key_system;
   if (!decryptor_.get()) {
-    base::AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(decryptor_lock_);
     decryptor_ = CreateDecryptor(key_system);
   }
 
-  DCHECK(client_);
   if (!decryptor_.get()) {
-    client_->KeyError(key_system, "", media::Decryptor::kUnknownError, 0);
+    DCHECK(client_);

[scherkus (not reviewing), 2012/07/26 02:06:38]

dcheck not needed

[xhwang, 2012/07/26 22:16:04]

Done.

+    client_->KeyError(key_system, "", Decryptor::kUnknownError, 0);
     return;
   }
 
   decryptor_->GenerateKeyRequest(key_system, init_data, init_data_length);
 }
 
 void ProxyDecryptor::AddKey(const std::string& key_system,
                             const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
+  DVLOG(1) << "AddKey()";
+
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
   DCHECK(decryptor_.get());
   decryptor_->AddKey(key_system, key, key_length, init_data, init_data_length,
                      session_id);
+
+  std::vector<base::Closure> closures_to_run;
+  {
+    base::AutoLock auto_lock(pending_decrypt_closures_lock_);
+    std::swap(pending_decrypt_closures_, closures_to_run);
+  }
+
+  for (std::vector<base::Closure>::iterator iter = closures_to_run.begin();
+       iter != closures_to_run.end();
+       ++iter) {
+    iter->Run();
+  }
 }
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& key_system,
                                       const std::string& session_id) {
+  DVLOG(1) << "CancelKeyRequest()";
+
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
   DCHECK(decryptor_.get());
   decryptor_->CancelKeyRequest(key_system, session_id);
 }
 
 void ProxyDecryptor::Decrypt(
-    const scoped_refptr<media::DecoderBuffer>& encrypted,
+    const scoped_refptr<DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
+  DVLOG(2) << "Decrypt()";
+
   // This is safe as we do not replace/delete an existing decryptor at run-time.
-  media::Decryptor* decryptor = NULL;
+  Decryptor* decryptor = NULL;
   {
-    base::AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(decryptor_lock_);
     decryptor = decryptor_.get();
   }
+
   if (!decryptor) {
     DVLOG(1) << "ProxyDecryptor::Decrypt(): decryptor not initialized.";
-    decrypt_cb.Run(kError, NULL);
+    {
+      base::AutoLock auto_lock(pending_decrypt_closures_lock_);
+      pending_decrypt_closures_.push_back(base::Bind(
+          &ProxyDecryptor::DecryptOnMessageLoop, base::Unretained(this),
+          base::MessageLoopProxy::current(), encrypted, decrypt_cb));
+    }
+    // TODO(xhwang): The same NeedKey may be fired here and multiple times in
+    // OnBufferDecrypted(). While the spec says only one NeedKey should be
+    // fired. Leave them as is since the spec about this may change.
+    FireNeedKey(client_, encrypted);
     return;
   }
 
-  decryptor->Decrypt(encrypted, decrypt_cb);
+  decryptor->Decrypt(encrypted, base::Bind(
+      &ProxyDecryptor::OnBufferDecrypted, base::Unretained(this),
+      base::MessageLoopProxy::current(), encrypted, decrypt_cb));
 }
 
-scoped_ptr<media::Decryptor> ProxyDecryptor::CreatePpapiDecryptor(
+scoped_ptr<Decryptor> ProxyDecryptor::CreatePpapiDecryptor(
     const std::string& key_system) {
   DCHECK(client_);
   DCHECK(web_media_player_client_);
   DCHECK(web_frame_);
 
   std::string plugin_type = GetPluginType(key_system);
   DCHECK(!plugin_type.empty());
   const scoped_refptr<webkit::ppapi::PluginInstance>& plugin_instance =
     CreatePluginInstance(plugin_type, web_media_player_client_, web_frame_);
   if (!plugin_instance) {
     DVLOG(1) << "PpapiDecryptor: plugin instance creation failed.";
-    return scoped_ptr<media::Decryptor>();
+    return scoped_ptr<Decryptor>();
   }
 
-  return scoped_ptr<media::Decryptor>(new PpapiDecryptor(client_,
-                                                         plugin_instance));
+  return scoped_ptr<Decryptor>(new PpapiDecryptor(client_, plugin_instance));
 }
 
-scoped_ptr<media::Decryptor> ProxyDecryptor::CreateDecryptor(
+scoped_ptr<Decryptor> ProxyDecryptor::CreateDecryptor(
     const std::string& key_system) {
   DCHECK(client_);
 
   if (CanUseAesDecryptor(key_system))
-    return scoped_ptr<media::Decryptor>(new media::AesDecryptor(client_));
+    return scoped_ptr<Decryptor>(new media::AesDecryptor(client_));
 
   // We only support AesDecryptor and PpapiDecryptor. So if we cannot
   // use the AesDecryptor, then we'll try to create a PpapiDecryptor for given
   // |key_system|.
   return CreatePpapiDecryptor(key_system);
 }
 
+void ProxyDecryptor::DecryptOnMessageLoop(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+    const scoped_refptr<DecoderBuffer>& encrypted,
+    const Decryptor::DecryptCB& decrypt_cb) {
+  DVLOG(2) << "DecryptOnMessageLoop()";
+  DCHECK(decryptor_.get());
+
+  if (!message_loop_proxy->BelongsToCurrentThread()) {
+    message_loop_proxy->PostTask(FROM_HERE, base::Bind(
+        &ProxyDecryptor::DecryptOnMessageLoop, base::Unretained(this),
+        message_loop_proxy, encrypted, decrypt_cb));
+    return;
+  }
+
+  decryptor_->Decrypt(encrypted, base::Bind(&ProxyDecryptor::OnBufferDecrypted,
+      base::Unretained(this), message_loop_proxy, encrypted, decrypt_cb));
+}
+
+void ProxyDecryptor::OnBufferDecrypted(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+    const scoped_refptr<DecoderBuffer>& encrypted,
+    const Decryptor::DecryptCB& decrypt_cb,
+    Decryptor::DecryptStatus status,
+    const scoped_refptr<DecoderBuffer>& decrypted) {
+  DVLOG(2) << "OnBufferDecrypted()";
+
+  if (status == Decryptor::kSuccess || status == Decryptor::kError) {
+    decrypt_cb.Run(status, decrypted);
+    return;
+  }
+
+  DCHECK_EQ(status, Decryptor::kNoKey);
+  DVLOG(1) << "OnBufferDecrypted(): kNoKey fired";
+  {
+    base::AutoLock auto_lock(pending_decrypt_closures_lock_);
+    pending_decrypt_closures_.push_back(base::Bind(
+        &ProxyDecryptor::DecryptOnMessageLoop, base::Unretained(this),
+        message_loop_proxy, encrypted, decrypt_cb));
+  }
+  // TODO(xhwang): The same NeedKey may be fired multiple times here and also
+  // in Decrypt(). While the spec says only one NeedKey should be fired. Leave
+  // them as is since the spec about this may change.
+  FireNeedKey(client_, encrypted);
+}
+
 }  // namespace webkit_media