media: Allow config change between clear and encrypted streams

content/renderer/pepper/content_decryptor_delegate.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 "content/renderer/pepper/content_decryptor_delegate.h"
 
 #include <string.h>
 #include <utility>
 #include <vector>
 
@@ skipping 76 matching lines @@
 // |array_size| is smaller than the |str| length.
 template <uint32_t array_size>
 bool CopyStringToArray(const std::string& str, uint8_t(&array)[array_size]) {
   if (array_size < str.size())
     return false;
 
   memcpy(array, str.data(), str.size());
   return true;
 }
 
-// Fills the |block_info| with information from |encrypted_buffer|.
+// Fills the |block_info| with information from |buffer|.
 //
 // Returns true if |block_info| is successfully filled. Returns false
 // otherwise.
-bool MakeEncryptedBlockInfo(
-    const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
-    uint32_t request_id,
-    PP_EncryptedBlockInfo* block_info) {
+bool MakeEncryptedBlockInfo(const scoped_refptr<media::DecoderBuffer>& buffer,
+                            uint32_t request_id,
+                            PP_EncryptedBlockInfo* block_info) {
   // TODO(xhwang): Fix initialization of PP_EncryptedBlockInfo here and
   // anywhere else.
   memset(block_info, 0, sizeof(*block_info));
   block_info->tracking_info.request_id = request_id;
 
   // EOS buffers need a request ID and nothing more.
-  if (encrypted_buffer->end_of_stream())
+  if (buffer->end_of_stream())
     return true;
 
-  DCHECK(encrypted_buffer->data_size())
-      << "DecryptConfig is set on an empty buffer";
+  DCHECK(buffer->data_size()) << "DecryptConfig is set on an empty buffer";
 
-  block_info->tracking_info.timestamp =
-      encrypted_buffer->timestamp().InMicroseconds();
-  block_info->data_size = encrypted_buffer->data_size();
+  block_info->tracking_info.timestamp = buffer->timestamp().InMicroseconds();
+  block_info->data_size = buffer->data_size();
 
-  const media::DecryptConfig* decrypt_config =
-      encrypted_buffer->decrypt_config();
+  const media::DecryptConfig* decrypt_config = buffer->decrypt_config();
+  if (!decrypt_config)
+    return true;
 
   if (!CopyStringToArray(decrypt_config->key_id(), block_info->key_id) ||
       !CopyStringToArray(decrypt_config->iv(), block_info->iv))
     return false;
 
   block_info->key_id_size = decrypt_config->key_id().size();
   block_info->iv_size = decrypt_config->iv().size();
 
   if (decrypt_config->subsamples().size() > arraysize(block_info->subsamples))
     return false;
@@ skipping 389 matching lines @@
           stream_type, encrypted_buffer, &encrypted_resource) ||
       !encrypted_resource.get()) {
     return false;
   }
   ScopedPPResource pp_resource(encrypted_resource.get());
 
   const uint32_t request_id = next_decryption_request_id_++;
   DVLOG(2) << "Decrypt() - request_id " << request_id;
 
   PP_EncryptedBlockInfo block_info = {};
-  DCHECK(encrypted_buffer->decrypt_config());
   if (!MakeEncryptedBlockInfo(encrypted_buffer, request_id, &block_info)) {
     return false;
   }
 
   // There is only one pending decrypt request at any time per stream. This is
   // enforced by the media pipeline.
   switch (stream_type) {
     case Decryptor::kAudio:
       audio_decrypt_cb_.Set(request_id, decrypt_cb);
       break;
@@ skipping 558 matching lines @@
       if (!video_decode_cb_.is_null())
         video_decode_cb_.ResetAndReturn().Run(Decryptor::kSuccess, NULL);
       break;
     default:
       NOTREACHED();
   }
 }
 
 bool ContentDecryptorDelegate::MakeMediaBufferResource(
     Decryptor::StreamType stream_type,
-    const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
+    const scoped_refptr<media::DecoderBuffer>& buffer,
     scoped_refptr<PPB_Buffer_Impl>* resource) {
   TRACE_EVENT0("media", "ContentDecryptorDelegate::MakeMediaBufferResource");
 
   // End of stream buffers are represented as null resources.
-  if (encrypted_buffer->end_of_stream()) {
+  if (buffer->end_of_stream()) {
     *resource = NULL;
     return true;
   }
 
   DCHECK(stream_type == Decryptor::kAudio || stream_type == Decryptor::kVideo);
   scoped_refptr<PPB_Buffer_Impl>& media_resource =
       (stream_type == Decryptor::kAudio) ? audio_input_resource_
                                          : video_input_resource_;
 
-  const size_t data_size = static_cast<size_t>(encrypted_buffer->data_size());
+  const size_t data_size = static_cast<size_t>(buffer->data_size());
   if (!media_resource.get() || media_resource->size() < data_size) {
     // Either the buffer hasn't been created yet, or we have one that isn't big
     // enough to fit |size| bytes.
 
     // Media resource size starts from |kMinimumMediaBufferSize| and grows
     // exponentially to avoid frequent re-allocation of PPB_Buffer_Impl,
     // which is usually expensive. Since input media buffers are compressed,
     // they are usually small (compared to outputs). The over-allocated memory
     // should be negligible.
     const uint32_t kMinimumMediaBufferSize = 1024;
@@ skipping 10 matching lines @@
         PPB_Buffer_Impl::CreateResource(pp_instance_, media_resource_size);
     if (!media_resource.get())
       return false;
   }
 
   BufferAutoMapper mapper(media_resource.get());
   if (!mapper.data() || mapper.size() < data_size) {
     media_resource = NULL;
     return false;
   }
-  memcpy(mapper.data(), encrypted_buffer->data(), data_size);
+  memcpy(mapper.data(), buffer->data(), data_size);
 
   *resource = media_resource;
   return true;
 }
 
 void ContentDecryptorDelegate::FreeBuffer(uint32_t buffer_id) {
   if (buffer_id)
     free_buffers_.push(buffer_id);
 }
 
@@ skipping 107 matching lines @@
 
   if (!video_decode_cb_.is_null())
     video_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
 
   cdm_promise_adapter_.Clear();
 
   cdm_session_tracker_.CloseRemainingSessions(session_closed_cb_);
 }
 
 }  // namespace content