Refactored DecoderBuffer to use unix_hacker_style naming.

media/crypto/aes_decryptor_unittest.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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 161 matching lines @@
 // Creates a WebM encrypted buffer that the demuxer would pass to the
 // decryptor. |data| is the payload of a WebM encrypted Block. |key_id| is
 // initialization data from the WebM file. Every encrypted Block has
 // a signal byte prepended to a frame. If the frame is encrypted then an IV is
 // prepended to the Block. Current encrypted WebM request for comments
 // specification is here
 // http://wiki.webmproject.org/encryption/webm-encryption-rfc
 static scoped_refptr<DecoderBuffer> CreateWebMEncryptedBuffer(
     const uint8* data, int data_size,
     const uint8* key_id, int key_id_size) {
-  scoped_refptr<DecoderBuffer> encrypted_buffer = DecoderBuffer::CopyFrom(
+  scoped_refptr<DecoderBuffer> encrypted_buffer = DecoderBuffer::copy_from(
       data, data_size);
   CHECK(encrypted_buffer.get());
   DCHECK_EQ(kWebMSignalByteSize, 1);
 
   uint8 signal_byte = data[0];
   int data_offset = kWebMSignalByteSize;
 
   // Setting the DecryptConfig object of the buffer while leaving the
   // initialization vector empty will tell the decryptor that the frame is
   // unencrypted.
@@ skipping 13 matching lines @@
   return encrypted_buffer;
 }
 
 static scoped_refptr<DecoderBuffer> CreateSubsampleEncryptedBuffer(
     const uint8* data, int data_size,
     const uint8* key_id, int key_id_size,
     const uint8* iv, int iv_size,
     int data_offset,
     const std::vector<SubsampleEntry>& subsample_entries) {
   scoped_refptr<DecoderBuffer> encrypted_buffer =
-      DecoderBuffer::CopyFrom(data, data_size);
+      DecoderBuffer::copy_from(data, data_size);
   CHECK(encrypted_buffer.get());
   encrypted_buffer->SetDecryptConfig(
       scoped_ptr<DecryptConfig>(new DecryptConfig(
           std::string(reinterpret_cast<const char*>(key_id), key_id_size),
           std::string(reinterpret_cast<const char*>(iv), iv_size),
           data_offset,
           subsample_entries)));
   return encrypted_buffer;
 }
 
@@ skipping 41 matching lines @@
                                      const scoped_refptr<DecoderBuffer>&));
 
   void DecryptAndExpectToSucceed(const scoped_refptr<DecoderBuffer>& encrypted,
                                  const uint8* plain_text, int plain_text_size) {
     scoped_refptr<DecoderBuffer> decrypted;
     EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kSuccess, NotNull()))
         .WillOnce(SaveArg<1>(&decrypted));
 
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     ASSERT_TRUE(decrypted.get());
-    ASSERT_EQ(plain_text_size, decrypted->GetDataSize());
-    EXPECT_EQ(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
+    ASSERT_EQ(plain_text_size, decrypted->get_data_size());
+    EXPECT_EQ(0, memcmp(plain_text, decrypted->get_data(), plain_text_size));
   }
 
   void DecryptAndExpectDataMismatch(
         const scoped_refptr<DecoderBuffer>& encrypted,
         const uint8* plain_text, int plain_text_size) {
     scoped_refptr<DecoderBuffer> decrypted;
     EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kSuccess, NotNull()))
         .WillOnce(SaveArg<1>(&decrypted));
 
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     ASSERT_TRUE(decrypted.get());
-    ASSERT_EQ(plain_text_size, decrypted->GetDataSize());
-    EXPECT_NE(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
+    ASSERT_EQ(plain_text_size, decrypted->get_data_size());
+    EXPECT_NE(0, memcmp(plain_text, decrypted->get_data(), plain_text_size));
   }
 
   void DecryptAndExpectSizeDataMismatch(
         const scoped_refptr<DecoderBuffer>& encrypted,
         const uint8* plain_text, int plain_text_size) {
     scoped_refptr<DecoderBuffer> decrypted;
     EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kSuccess, NotNull()))
         .WillOnce(SaveArg<1>(&decrypted));
 
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     ASSERT_TRUE(decrypted.get());
-    EXPECT_NE(plain_text_size, decrypted->GetDataSize());
-    EXPECT_NE(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
+    EXPECT_NE(plain_text_size, decrypted->get_data_size());
+    EXPECT_NE(0, memcmp(plain_text, decrypted->get_data(), plain_text_size));
   }
 
   void DecryptAndExpectToFail(const scoped_refptr<DecoderBuffer>& encrypted) {
     EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kError, IsNull()));
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
   }
 
   MOCK_METHOD1(KeyAdded, void(const std::string&));
   MOCK_METHOD3(KeyError, void(const std::string&,
                               MediaKeys::KeyError, int));
@@ skipping 279 matching lines @@
   scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer(
       kSubsampleData, arraysize(kSubsampleData),
       kSubsampleKeyId, arraysize(kSubsampleKeyId),
       kSubsampleIv, arraysize(kSubsampleIv),
       0,
       entries);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToFail(encrypted_data));
 }
 
 }  // namespace media