Refactored DecoderBuffer to use unix_hacker_style naming.

media/crypto/aes_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 "media/crypto/aes_decryptor.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 29 matching lines @@
     memcpy(dst, src, subsample.cypher_bytes);
     src += subsample.cypher_bytes;
     dst += subsample.cypher_bytes;
   }
 }
 
 // Decrypts |input| using |key|.  Returns a DecoderBuffer with the decrypted
 // data if decryption succeeded or NULL if decryption failed.
 static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input,
                                                 crypto::SymmetricKey* key) {
-  CHECK(input.GetDataSize());
-  CHECK(input.GetDecryptConfig());
+  CHECK(input.data_size());
+  CHECK(input.decrypt_config());
   CHECK(key);
 
   crypto::Encryptor encryptor;
   if (!encryptor.Init(key, crypto::Encryptor::CTR, "")) {
     DVLOG(1) << "Could not initialize decryptor.";
     return NULL;
   }
 
-  DCHECK_EQ(input.GetDecryptConfig()->iv().size(),
+  DCHECK_EQ(input.decrypt_config()->iv().size(),
             static_cast<size_t>(DecryptConfig::kDecryptionKeySize));
-  if (!encryptor.SetCounter(input.GetDecryptConfig()->iv())) {
+  if (!encryptor.SetCounter(input.decrypt_config()->iv())) {
     DVLOG(1) << "Could not set counter block.";
     return NULL;
   }
 
-  const int data_offset = input.GetDecryptConfig()->data_offset();
+  const int data_offset = input.decrypt_config()->data_offset();
   const char* sample =
-      reinterpret_cast<const char*>(input.GetData() + data_offset);
-  int sample_size = input.GetDataSize() - data_offset;
+      reinterpret_cast<const char*>(input.data() + data_offset);
+  int sample_size = input.data_size() - data_offset;
 
-  if (input.GetDecryptConfig()->subsamples().empty()) {
+  if (input.decrypt_config()->subsamples().empty()) {
     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());
   }
 
   const std::vector<SubsampleEntry>& subsamples =
-      input.GetDecryptConfig()->subsamples();
+      input.decrypt_config()->subsamples();
 
   int total_clear_size = 0;
   int 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;
   }
   if (total_clear_size + total_encrypted_size != sample_size) {
     DVLOG(1) << "Subsample sizes do not equal input size";
     return NULL;
@@ skipping 15 matching lines @@
   std::string decrypted_text;
   if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) {
     DVLOG(1) << "Could not decrypt data.";
     return NULL;
   }
 
   scoped_refptr<DecoderBuffer> output = DecoderBuffer::CopyFrom(
       reinterpret_cast<const uint8*>(sample), sample_size);
   CopySubsamples(subsamples, kDstContainsClearBytes,
                  reinterpret_cast<const uint8*>(decrypted_text.data()),
-                 output->GetWritableData());
+                 output->writable_data());
   return output;
 }
 
 AesDecryptor::AesDecryptor(const KeyAddedCB& key_added_cb,
                            const KeyErrorCB& key_error_cb,
                            const KeyMessageCB& key_message_cb,
                            const NeedKeyCB& need_key_cb)
     : key_added_cb_(key_added_cb),
       key_error_cb_(key_error_cb),
       key_message_cb_(key_message_cb),
@@ skipping 91 matching lines @@
       new_video_key_cb_ = new_key_cb;
       break;
     default:
       NOTREACHED();
   }
 }
 
 void AesDecryptor::Decrypt(StreamType stream_type,
                            const scoped_refptr<DecoderBuffer>& encrypted,
                            const DecryptCB& decrypt_cb) {
-  CHECK(encrypted->GetDecryptConfig());
+  CHECK(encrypted->decrypt_config());
 
   scoped_refptr<DecoderBuffer> decrypted;
   // An empty iv string signals that the frame is unencrypted.
-  if (encrypted->GetDecryptConfig()->iv().empty()) {
-    int data_offset = encrypted->GetDecryptConfig()->data_offset();
-    decrypted = DecoderBuffer::CopyFrom(encrypted->GetData() + data_offset,
-                                        encrypted->GetDataSize() - data_offset);
+  if (encrypted->decrypt_config()->iv().empty()) {
+    int data_offset = encrypted->decrypt_config()->data_offset();
+    decrypted = DecoderBuffer::CopyFrom(encrypted->data() + data_offset,
+                                        encrypted->data_size() - data_offset);
   } else {
-    const std::string& key_id = encrypted->GetDecryptConfig()->key_id();
+    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();
     decrypted = DecryptData(*encrypted.get(), decryption_key);
     if (!decrypted.get()) {
       DVLOG(1) << "Decryption failed.";
       decrypt_cb.Run(kError, NULL);
       return;
     }
   }
 
-  decrypted->SetTimestamp(encrypted->GetTimestamp());
-  decrypted->SetDuration(encrypted->GetDuration());
+  decrypted->set_timestamp(encrypted->timestamp());
+  decrypted->set_duration(encrypted->duration());
   decrypt_cb.Run(kSuccess, decrypted);
 }
 
 void AesDecryptor::CancelDecrypt(StreamType stream_type) {
   // Decrypt() calls the DecryptCB synchronously so there's nothing to cancel.
 }
 
 void AesDecryptor::InitializeAudioDecoder(const AudioDecoderConfig& config,
                                           const DecoderInitCB& init_cb) {
   // AesDecryptor does not support audio decoding.
@@ skipping 56 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