Update PluginInstance for audio support for content decryption.

webkit/media/crypto/ppapi_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/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 18 matching lines @@
       cdm_plugin_(plugin_instance),
       render_loop_proxy_(base::MessageLoopProxy::current()),
       weak_ptr_factory_(this),
       weak_this_(weak_ptr_factory_.GetWeakPtr()) {
   DCHECK(client_);
   DCHECK(cdm_plugin_);
   cdm_plugin_->set_decrypt_client(client);
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
+  cdm_plugin_->set_decrypt_client(NULL);
 }
 
 bool PpapiDecryptor::GenerateKeyRequest(const std::string& key_system,
                                         const uint8* init_data,
                                         int init_data_length) {
   DVLOG(2) << "GenerateKeyRequest()";
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   DCHECK(cdm_plugin_);
 
   // TODO(xhwang): Finalize the data type for |init_data| to avoid unnecessary
@@ skipping 49 matching lines @@
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::Decrypt, weak_this_,
         stream_type, encrypted, decrypt_cb));
     return;
   }
 
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
-  if (!cdm_plugin_->Decrypt(encrypted, decrypt_cb))
+  if (!cdm_plugin_->Decrypt(stream_type, encrypted, decrypt_cb))
     decrypt_cb.Run(kError, NULL);
 }
 
 void PpapiDecryptor::CancelDecrypt(StreamType stream_type) {
   DVLOG(1) << "CancelDecrypt() - stream_type: " << stream_type;
-  // TODO(xhwang): Implement CancelDecrypt() in PluginInstance and call it here.
+  cdm_plugin_->CancelDecrypt(stream_type);
 }
 
 void PpapiDecryptor::InitializeAudioDecoder(
       scoped_ptr<media::AudioDecoderConfig> config,
       const DecoderInitCB& init_cb,
       const KeyAddedCB& key_added_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::InitializeAudioDecoder, weak_this_,
         base::Passed(&config), init_cb, key_added_cb));
     return;
   }
 
   DVLOG(2) << "InitializeAudioDecoder()";
   DCHECK(config->is_encrypted());
   DCHECK(config->IsValidConfig());
 
   audio_decoder_init_cb_ = init_cb;
-  // TODO(xhwang): Implement InitializeAudioDecoder() in PluginInstance and call
-  // it here.
-  NOTIMPLEMENTED();
-#if 0
   if (!cdm_plugin_->InitializeAudioDecoder(*config, base::Bind(
       &PpapiDecryptor::OnDecoderInitialized, weak_this_,
       kAudio, key_added_cb))) {
-#endif
     base::ResetAndReturn(&audio_decoder_init_cb_).Run(false);
-#if 0
     return;
   }
-#endif
 }
 
 void PpapiDecryptor::InitializeVideoDecoder(
     scoped_ptr<media::VideoDecoderConfig> config,
     const DecoderInitCB& init_cb,
     const KeyAddedCB& key_added_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::InitializeVideoDecoder, weak_this_,
         base::Passed(&config), init_cb, key_added_cb));
@@ skipping 17 matching lines @@
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const AudioDecodeCB& audio_decode_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::DecryptAndDecodeAudio, weak_this_,
         encrypted, audio_decode_cb));
     return;
   }
 
   DVLOG(1) << "DecryptAndDecodeAudio()";
-  NOTIMPLEMENTED();
-  // TODO(xhwang): Enable this once PluginInstance is updated.
-#if 0
   if (!cdm_plugin_->DecryptAndDecodeAudio(encrypted, audio_decode_cb))
-#endif
     audio_decode_cb.Run(kError, AudioBuffers());
 }
 
 void PpapiDecryptor::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::DecryptAndDecodeVideo, weak_this_,
         encrypted, video_decode_cb));
     return;
   }
 
   DVLOG(3) << "DecryptAndDecodeVideo()";
-  if (!cdm_plugin_->DecryptAndDecode(encrypted, video_decode_cb))
+  if (!cdm_plugin_->DecryptAndDecodeVideo(encrypted, video_decode_cb))
     video_decode_cb.Run(kError, NULL);
 }
 
 void PpapiDecryptor::ResetDecoder(StreamType stream_type) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::ResetDecoder, weak_this_, stream_type));
     return;
   }
 
   DVLOG(2) << "ResetDecoder() - stream_type: " << stream_type;
-  // TODO(xhwang): Support stream type in PluginInstance.
-  cdm_plugin_->ResetDecoder();
+  cdm_plugin_->ResetDecoder(stream_type);
 }
 
 void PpapiDecryptor::DeinitializeDecoder(StreamType stream_type) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
     render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &PpapiDecryptor::DeinitializeDecoder, weak_this_, stream_type));
     return;
   }
   DVLOG(2) << "DeinitializeDecoder() - stream_type: " << stream_type;
-  // TODO(xhwang): Support stream type in PluginInstance.
-  cdm_plugin_->DeinitializeDecoder();
+  cdm_plugin_->DeinitializeDecoder(stream_type);
 }
 
 void PpapiDecryptor::ReportFailureToCallPlugin(const std::string& key_system,
                                                const std::string& session_id) {
   DVLOG(1) << "Failed to call plugin.";
   client_->KeyError(key_system, session_id, kUnknownError, 0);
 }
 
 void PpapiDecryptor::OnDecoderInitialized(StreamType stream_type,
                                           const KeyAddedCB& key_added_cb,
@@ skipping 16 matching lines @@
         video_key_added_cb_ = key_added_cb;
       base::ResetAndReturn(&video_decoder_init_cb_).Run(success);
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace webkit_media