Allow null buffer resources to be returned through the PPB_ContentDecryptor_Private proxy.

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"
@@ skipping 136 matching lines @@
                                       const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
   // WebMediaPlayerImpl ensures GenerateKeyRequest() has been called.
   decryptor_->CancelKeyRequest(key_system, session_id);
 }
 
 void ProxyDecryptor::Decrypt(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
+  DVLOG(2) << "Decrypt()";
   DCHECK(decryption_message_loop_->BelongsToCurrentThread());
 
   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) << "ProxyDecryptor::Decrypt(): decryptor not initialized.";
+    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() {
+  DVLOG(1) << "CancelDecrypt()";
   DCHECK(decryption_message_loop_->BelongsToCurrentThread());
 
   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_) {
@@ skipping 78 matching lines @@
 
   if (is_waiting_for_decryptor_) {
     has_new_key_added_ = true;
     return;
   }
 
   DecryptPendingBuffer();
 }
 
 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(
       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),
         status, decrypted));
     return;
   }
 
+  DVLOG(2) << "OnBufferDecrypted() - status: " << status;

[brettw, 2012/10/12 19:44:06]

I don't undrestand these DVLOG priorities. They seem random. Should we use (1)
everywhere or is there some logic behind the 1, 2, and 3 that you actually use?

   DCHECK(pending_buffer_to_decrypt_);
   DCHECK(!pending_decrypt_cb_.is_null());
   DCHECK(is_waiting_for_decryptor_);
 
   is_waiting_for_decryptor_ = false;
   bool need_to_try_again_if_nokey_is_returned = has_new_key_added_;
   has_new_key_added_ = false;
 
   if (is_canceling_decrypt_) {
     pending_buffer_to_decrypt_ = NULL;
@@ skipping 16 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