Move key frame flag from StreamParserBuffer to DecoderBuffer

media/cdm/aes_decryptor.cc

 // Copyright 2013 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 "media/cdm/aes_decryptor.h"
 
 #include <list>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 149 matching lines @@
     std::string decrypted_text;
     base::StringPiece encrypted_text(sample, sample_size);
     if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
       DVLOG(1) << "Could not decrypt data.";
       return NULL;
     }
 
     // TODO(xhwang): Find a way to avoid this data copy.
     return DecoderBuffer::CopyFrom(
         reinterpret_cast<const uint8*>(decrypted_text.data()),
-        decrypted_text.size());
+        decrypted_text.size(),
+        false);
   }
 
   const std::vector<SubsampleEntry>& subsamples =
       input.decrypt_config()->subsamples();
 
   size_t total_clear_size = 0;
   size_t total_encrypted_size = 0;
   for (size_t i = 0; i < subsamples.size(); i++) {
     total_clear_size += subsamples[i].clear_bytes;
     total_encrypted_size += subsamples[i].cypher_bytes;
     // Check for overflow. This check is valid because *_size is unsigned.
     DCHECK(total_clear_size >= subsamples[i].clear_bytes);
     if (total_encrypted_size < subsamples[i].cypher_bytes)
       return NULL;
   }
   size_t total_size = total_clear_size + total_encrypted_size;
   if (total_size < total_clear_size || total_size != sample_size) {
     DVLOG(1) << "Subsample sizes do not equal input size";
     return NULL;
   }
 
   // No need to decrypt if there is no encrypted data.
   if (total_encrypted_size <= 0) {
     return DecoderBuffer::CopyFrom(reinterpret_cast<const uint8*>(sample),
-                                   sample_size);
+                                   sample_size,
+                                   false);
   }
 
   // The encrypted portions of all subsamples must form a contiguous block,
   // such that an encrypted subsample that ends away from a block boundary is
   // immediately followed by the start of the next encrypted subsample. We
   // copy all encrypted subsamples to a contiguous buffer, decrypt them, then
   // copy the decrypted bytes over the encrypted bytes in the output.
   // TODO(strobe): attempt to reduce number of memory copies
   scoped_ptr<uint8[]> encrypted_bytes(new uint8[total_encrypted_size]);
   CopySubsamples(subsamples, kSrcContainsClearBytes,
                  reinterpret_cast<const uint8*>(sample), encrypted_bytes.get());
 
   base::StringPiece encrypted_text(
       reinterpret_cast<const char*>(encrypted_bytes.get()),
       total_encrypted_size);
   std::string decrypted_text;
   if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
     DVLOG(1) << "Could not decrypt data.";
     return NULL;
   }
   DCHECK_EQ(decrypted_text.size(), encrypted_text.size());
 
   scoped_refptr<DecoderBuffer> output = DecoderBuffer::CopyFrom(
-      reinterpret_cast<const uint8*>(sample), sample_size);
+      reinterpret_cast<const uint8*>(sample), sample_size, false);
   CopySubsamples(subsamples, kDstContainsClearBytes,
                  reinterpret_cast<const uint8*>(decrypted_text.data()),
                  output->writable_data());
   return output;
 }
 
 AesDecryptor::AesDecryptor(const SessionMessageCB& session_message_cb,
                            const SessionClosedCB& session_closed_cb,
                            const SessionKeysChangeCB& session_keys_change_cb)
     : session_message_cb_(session_message_cb),
@@ skipping 182 matching lines @@
 
 void AesDecryptor::Decrypt(StreamType stream_type,
                            const scoped_refptr<DecoderBuffer>& encrypted,
                            const DecryptCB& decrypt_cb) {
   CHECK(encrypted->decrypt_config());
 
   scoped_refptr<DecoderBuffer> decrypted;
   // An empty iv string signals that the frame is unencrypted.
   if (encrypted->decrypt_config()->iv().empty()) {
     decrypted = DecoderBuffer::CopyFrom(encrypted->data(),
-                                        encrypted->data_size());
+                                        encrypted->data_size(),
+                                        false);
   } else {
     const std::string& key_id = encrypted->decrypt_config()->key_id();
     DecryptionKey* key = GetKey(key_id);
     if (!key) {
       DVLOG(1) << "Could not find a matching key for the given key ID.";
       decrypt_cb.Run(kNoKey, NULL);
       return;
     }
 
     crypto::SymmetricKey* decryption_key = key->decryption_key();
@@ skipping 111 matching lines @@
 bool AesDecryptor::DecryptionKey::Init() {
   CHECK(!secret_.empty());
   decryption_key_.reset(crypto::SymmetricKey::Import(
       crypto::SymmetricKey::AES, secret_));
   if (!decryption_key_)
     return false;
   return true;
 }
 
 }  // namespace media