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 <algorithm>
+
 #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) {
+                        const scoped_refptr<media::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);
+  std::string key_id = encrypted->GetDecryptConfig()->key_id();
+  scoped_array<uint8> key_id_array(new uint8[key_id.size()]);
+  memcpy(key_id_array.get(), key_id.data(), 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) {
+      web_frame_(web_frame),
+      is_shutting_down_(false) {
 }
 
 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(decryptor_lock_);
+    base::AutoLock auto_lock(lock_);
     decryptor_ = CreateDecryptor(key_system);
   }
 
   if (!decryptor_.get()) {
-    DCHECK(client_);
-    client_->KeyError(key_system, "", Decryptor::kUnknownError, 0);
+    client_->KeyError(key_system, "", media::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_);
+    base::AutoLock auto_lock(lock_);
     std::swap(pending_decrypt_closures_, closures_to_run);
   }
 
+  // Fire all pending callbacks here because only the |decryptor_| knows if the
+  // pending buffers can be decrypted or not.
   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<DecoderBuffer>& encrypted,
+    const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
-  DVLOG(2) << "Decrypt()";
-
   // This is safe as we do not replace/delete an existing decryptor at run-time.
-  Decryptor* decryptor = NULL;
+  media::Decryptor* decryptor = NULL;
   {
-    base::AutoLock auto_lock(decryptor_lock_);
+    base::AutoLock auto_lock(lock_);
+    if (is_shutting_down_) {
+      DVLOG(1) << "Decrypt(): fire decrypt callbacks with kError.";
+      decrypt_cb.Run(kError, NULL);
+      return;
+    }
     decryptor = decryptor_.get();
-  }
-
-  if (!decryptor) {
-    DVLOG(1) << "ProxyDecryptor::Decrypt(): decryptor not initialized.";
-    {
-      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));
+    if (!decryptor) {
+      DVLOG(1) << "ProxyDecryptor::Decrypt(): decryptor not initialized.";
+      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;
     }
-    // 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, base::Bind(
       &ProxyDecryptor::OnBufferDecrypted, base::Unretained(this),
       base::MessageLoopProxy::current(), encrypted, decrypt_cb));
 }
 
-scoped_ptr<Decryptor> ProxyDecryptor::CreatePpapiDecryptor(
+void ProxyDecryptor::Stop() {
+  DVLOG(1) << "AddKey()";
+
+  std::vector<base::Closure> closures_to_run;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (decryptor_.get())
+      decryptor_->Stop();
+    is_shutting_down_ = true;
+    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();
+  }
+}
+
+scoped_ptr<media::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<Decryptor>();
+    return scoped_ptr<media::Decryptor>();
   }
 
-  return scoped_ptr<Decryptor>(new PpapiDecryptor(client_, plugin_instance));
+  return scoped_ptr<media::Decryptor>(new PpapiDecryptor(client_,
+                                                         plugin_instance));
 }
 
-scoped_ptr<Decryptor> ProxyDecryptor::CreateDecryptor(
+scoped_ptr<media::Decryptor> ProxyDecryptor::CreateDecryptor(
     const std::string& key_system) {
   DCHECK(client_);
 
   if (CanUseAesDecryptor(key_system))
-    return scoped_ptr<Decryptor>(new media::AesDecryptor(client_));
+    return scoped_ptr<media::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()";
+    const scoped_refptr<media::DecoderBuffer>& encrypted,
+    const media::Decryptor::DecryptCB& decrypt_cb) {
   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;
   }
 
+  {
+    base::AutoLock auto_lock(lock_);
+    if (is_shutting_down_) {
+      DVLOG(1) << "DecryptOnMessageLoop(): fire decrypt callbacks with kError.";
+      decrypt_cb.Run(kError, NULL);
+      return;
+    }
+  }
+
   decryptor_->Decrypt(encrypted, base::Bind(&ProxyDecryptor::OnBufferDecrypted,

[scherkus (not reviewing), 2012/08/02 18:05:32]

nit: technically this is mixing style: params on next line would be aligned w/
first arg at base::Bind(

can you drop the &ProxyDecryptor::OBD to next line as done on line 159-161?

[xhwang, 2012/08/03 20:08:10]

Done.

       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) {
+    const scoped_refptr<media::DecoderBuffer>& encrypted,
+    const media::Decryptor::DecryptCB& decrypt_cb,
+    media::Decryptor::DecryptStatus status,
+    const scoped_refptr<media::DecoderBuffer>& decrypted) {
+  if (status == media::Decryptor::kSuccess ||
+      status == media::Decryptor::kError) {
     decrypt_cb.Run(status, decrypted);
     return;
   }
 
-  DCHECK_EQ(status, Decryptor::kNoKey);
+  DCHECK_EQ(status, media::Decryptor::kNoKey);
   DVLOG(1) << "OnBufferDecrypted(): kNoKey fired";
   {
-    base::AutoLock auto_lock(pending_decrypt_closures_lock_);
+    base::AutoLock auto_lock(lock_);
+    if (is_shutting_down_) {
+      DVLOG(1) << "OnBufferDecrypted(): fire decrypt callbacks with kError.";
+      decrypt_cb.Run(kError, NULL);
+      return;
+    }
     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