Update Decryptor interface to support audio decoding.

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/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
+#include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decryptor_client.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.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"
@@ skipping 123 matching lines @@
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& key_system,
                                       const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
   decryptor_->CancelKeyRequest(key_system, session_id);
 }
 
 void ProxyDecryptor::Decrypt(
+    StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
   DVLOG(2) << "Decrypt()";
   DCHECK(decryption_message_loop_->BelongsToCurrentThread());
+  DCHECK_EQ(stream_type, kVideo);  // Only support video decrypt-only for now.
 
   DCHECK(!is_canceling_decrypt_);
   DCHECK(!pending_buffer_to_decrypt_);
   DCHECK(pending_decrypt_cb_.is_null());
 
   pending_buffer_to_decrypt_ = encrypted;
   pending_decrypt_cb_ = decrypt_cb;
 
   // This is safe as we do not replace/delete an existing decryptor at run-time.
   media::Decryptor* decryptor = NULL;
   {
     base::AutoLock auto_lock(lock_);
     decryptor = decryptor_.get();
   }
   if (!decryptor) {
     DVLOG(1) << "Decrypt(): decryptor not initialized.";
 
     // 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;
   }
 
   DecryptPendingBuffer();
 }
 
-void ProxyDecryptor::CancelDecrypt() {
+void ProxyDecryptor::CancelDecrypt(StreamType stream_type) {
   DVLOG(1) << "CancelDecrypt()";
   DCHECK(decryption_message_loop_->BelongsToCurrentThread());
+  DCHECK_EQ(stream_type, kVideo);  // Only support video decrypt-only for now.
 
   if (!pending_buffer_to_decrypt_) {
     DCHECK(pending_decrypt_cb_.is_null());
     DCHECK(!is_waiting_for_decryptor_);
     return;
   }
 
   DecryptCB decrypt_cb;
   if (!is_waiting_for_decryptor_) {
     pending_buffer_to_decrypt_ = NULL;
     base::ResetAndReturn(&pending_decrypt_cb_).Run(kSuccess, NULL);
     return;
   }
 
   is_canceling_decrypt_ = true;
-  decryptor_->CancelDecrypt();
+  decryptor_->CancelDecrypt(stream_type);
+}
+
+void ProxyDecryptor::InitializeAudioDecoder(
+    scoped_ptr<media::AudioDecoderConfig> config,
+    const DecoderInitCB& init_cb,
+    const KeyAddedCB& key_added_cb) {
+  NOTREACHED() << "ProxyDecryptor does not support audio decoding";
 }
 
 void ProxyDecryptor::InitializeVideoDecoder(
     scoped_ptr<media::VideoDecoderConfig> config,
     const DecoderInitCB& init_cb,
     const KeyAddedCB& key_added_cb) {
   NOTREACHED() << "ProxyDecryptor does not support video decoding";
 }
 
+void ProxyDecryptor::DecryptAndDecodeAudio(
+    const scoped_refptr<media::DecoderBuffer>& encrypted,
+    const AudioDecodeCB& audio_decode_cb) {
+  NOTREACHED() << "ProxyDecryptor does not support audio decoding";
+}
+
 void ProxyDecryptor::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   NOTREACHED() << "ProxyDecryptor does not support video decoding";
 }
 
-void ProxyDecryptor::CancelDecryptAndDecodeVideo() {
-  NOTREACHED() << "ProxyDecryptor does not support video decoding";
+void ProxyDecryptor::ResetDecoder(StreamType stream_type) {
+  NOTREACHED() << "ProxyDecryptor does not support audio/video decoding";
 }
 
-void ProxyDecryptor::StopVideoDecoder() {
-  NOTREACHED() << "ProxyDecryptor does not support video decoding";
+void ProxyDecryptor::DeinitializeDecoder(StreamType stream_type) {
+  NOTREACHED() << "ProxyDecryptor does not support audio/video decoding";
 }
 
 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());
@@ skipping 47 matching lines @@
 }
 
 void ProxyDecryptor::DecryptPendingBuffer() {
   DVLOG(3) << "DecryptPendingBuffer()";
   DCHECK(decryption_message_loop_->BelongsToCurrentThread());
   DCHECK(pending_buffer_to_decrypt_);
   DCHECK(!is_waiting_for_decryptor_);
 
   is_waiting_for_decryptor_ = true;
   decryptor_->Decrypt(
+      kVideo,  // Only support video decrypt-only for now.
       pending_buffer_to_decrypt_,
       base::Bind(&ProxyDecryptor::OnBufferDecrypted, base::Unretained(this)));
 }
 
 void ProxyDecryptor::OnBufferDecrypted(
     media::Decryptor::Status status,
     const scoped_refptr<media::DecoderBuffer>& decrypted) {
   if (!decryption_message_loop_->BelongsToCurrentThread()) {
     decryption_message_loop_->PostTask(FROM_HERE, base::Bind(
         &ProxyDecryptor::OnBufferDecrypted, base::Unretained(this),
@@ skipping 31 matching lines @@
     return;
   }
 
   // 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_, pending_buffer_to_decrypt_);
 }
 
 }  // namespace webkit_media