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 77 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;

[bbudge, 2017/02/15 15:46:13]

It seems strange to return true here, if the block info hasn't been filled in.

[xhwang, 2017/02/15 17:30:20]

The struct is initialized at line 107. Then when the buffer is not encrypted,
there's no need to fill any of the fields below as they are only used for
decryption.

I added a comment to make this more clear.

 
   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 388 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 563 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