Refactored DecoderBuffer to use unix_hacker_style naming.

webkit/renderer/media/crypto/ppapi/clear_key_cdm.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 "webkit/renderer/media/crypto/ppapi/clear_key_cdm.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
@@ skipping 80 matching lines @@
   }
 
   scoped_ptr<media::DecryptConfig> decrypt_config(new media::DecryptConfig(
       std::string(reinterpret_cast<const char*>(input_buffer.key_id),
                   input_buffer.key_id_size),
       std::string(reinterpret_cast<const char*>(input_buffer.iv),
                   input_buffer.iv_size),
       input_buffer.data_offset,
       subsamples));
 
-  output_buffer->SetDecryptConfig(decrypt_config.Pass());
-  output_buffer->SetTimestamp(
+  output_buffer->set_decrypt_config(decrypt_config.Pass());
+  output_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(input_buffer.timestamp));
 
   return output_buffer;
 }
 
 template<typename Type>
 class ScopedResetter {
  public:
   explicit ScopedResetter(Type* object) : object_(object) {}
   ~ScopedResetter() { object_->Reset(); }
@@ skipping 189 matching lines @@
     cdm::DecryptedBlock* decrypted_block) {
   DVLOG(1) << "Decrypt()";
   DCHECK(encrypted_buffer.data);
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
-  DCHECK(buffer->GetData());
+  DCHECK(buffer->data());
   decrypted_block->SetDecryptedBuffer(
-      host_->Allocate(buffer->GetDataSize()));
+      host_->Allocate(buffer->data_size()));
   memcpy(reinterpret_cast<void*>(decrypted_block->DecryptedBuffer()->Data()),
-         buffer->GetData(),
-         buffer->GetDataSize());
-  decrypted_block->DecryptedBuffer()->SetSize(buffer->GetDataSize());
-  decrypted_block->SetTimestamp(buffer->GetTimestamp().InMicroseconds());
+         buffer->data(),
+         buffer->data_size());
+  decrypted_block->DecryptedBuffer()->SetSize(buffer->data_size());
+  decrypted_block->SetTimestamp(buffer->timestamp().InMicroseconds());
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::InitializeAudioDecoder(
     const cdm::AudioDecoderConfig& audio_decoder_config) {
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   if (!audio_decoder_)
     audio_decoder_.reset(new webkit_media::FFmpegCdmAudioDecoder(host_));
 
@@ skipping 75 matching lines @@
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
   const uint8_t* data = NULL;
   int32_t size = 0;
   int64_t timestamp = 0;
-  if (!buffer->IsEndOfStream()) {
-    data = buffer->GetData();
-    size = buffer->GetDataSize();
+  if (!buffer->end_of_stream()) {
+    data = buffer->data();
+    size = buffer->data_size();
     timestamp = encrypted_buffer.timestamp;
   }
 
   return video_decoder_->DecodeFrame(data, size, timestamp, decoded_frame);
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
     const cdm::InputBuffer& encrypted_buffer,
     cdm::AudioFrames* audio_frames) {
   DVLOG(1) << "DecryptAndDecodeSamples()";
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   const uint8_t* data = NULL;
   int32_t size = 0;
   int64_t timestamp = 0;
-  if (!buffer->IsEndOfStream()) {
-    data = buffer->GetData();
-    size = buffer->GetDataSize();
+  if (!buffer->end_of_stream()) {
+    data = buffer->data();
+    size = buffer->data_size();
     timestamp = encrypted_buffer.timestamp;
   }
 
   return audio_decoder_->DecodeBuffer(data, size, timestamp, audio_frames);
 #elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   int64 timestamp_in_microseconds = kNoTimestamp;
-  if (!buffer->IsEndOfStream()) {
+  if (!buffer->end_of_stream()) {
     timestamp_in_microseconds = buffer->GetTimestamp().InMicroseconds();
     DCHECK(timestamp_in_microseconds != kNoTimestamp);
   }
   return GenerateFakeAudioFrames(timestamp_in_microseconds, audio_frames);
 #else
   return cdm::kSuccess;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
 void ClearKeyCdm::Destroy() {
@@ skipping 16 matching lines @@
     timer_delay_ms_ = std::min(2 * timer_delay_ms_, kMaxTimerDelayMs);
 }
 
 cdm::Status ClearKeyCdm::DecryptToMediaDecoderBuffer(
     const cdm::InputBuffer& encrypted_buffer,
     scoped_refptr<media::DecoderBuffer>* decrypted_buffer) {
   DCHECK(decrypted_buffer);
   scoped_refptr<media::DecoderBuffer> buffer =
       CopyDecoderBufferFrom(encrypted_buffer);
 
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     *decrypted_buffer = buffer;
     return cdm::kSuccess;
   }
 
   // Callback is called synchronously, so we can use variables on the stack.
   media::Decryptor::Status status = media::Decryptor::kError;
   // The AesDecryptor does not care what the stream type is. Pass kVideo
   // for both audio and video decryption.
   decryptor_.Decrypt(
       media::Decryptor::kVideo,
@@ skipping 63 matching lines @@
   int samples_generated = GenerateFakeAudioFramesFromDuration(
       timestamp_in_microseconds - CurrentTimeStampInMicroseconds(),
       audio_frames);
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 }  // namespace webkit_media