Refactored DecoderBuffer to use unix_hacker_style naming.

webkit/plugins/ppapi/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 "webkit/plugins/ppapi/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 69 matching lines @@
 // otherwise.
 static bool MakeEncryptedBlockInfo(
     const scoped_refptr<media::DecoderBuffer>& encrypted_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->IsEndOfStream()) return true;
+  if (encrypted_buffer->is_end_of_stream()) return true;
 
-  DCHECK(encrypted_buffer->GetDataSize())
+  DCHECK(encrypted_buffer->get_data_size())
       << "DecryptConfig is set on an empty buffer";
 
   block_info->tracking_info.timestamp =
-      encrypted_buffer->GetTimestamp().InMicroseconds();
-  block_info->data_size = encrypted_buffer->GetDataSize();
+      encrypted_buffer->get_timestamp().InMicroseconds();
+  block_info->data_size = encrypted_buffer->get_data_size();
 
   const media::DecryptConfig* decrypt_config =
-      encrypted_buffer->GetDecryptConfig();
+      encrypted_buffer->get_decrypt_config();
   block_info->data_offset = decrypt_config->data_offset();
 
   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))
@@ skipping 229 matching lines @@
                                &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->GetDecryptConfig());
+  DCHECK(encrypted_buffer->get_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 media::Decryptor::kAudio:
       DCHECK_EQ(pending_audio_decrypt_request_id_, 0u);
       DCHECK(pending_audio_decrypt_cb_.is_null());
@@ skipping 142 matching lines @@
   // |audio_input_resource_| is not being used by the plugin now
   // because there is only one pending audio decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(media::Decryptor::kAudio, encrypted_buffer,
                                &encrypted_resource)) {
     return false;
   }
 
   // The resource should not be NULL for non-EOS buffer.
-  if (!encrypted_buffer->IsEndOfStream() && !encrypted_resource.get())
+  if (!encrypted_buffer->is_end_of_stream() && !encrypted_resource.get())
     return false;
 
   const uint32_t request_id = next_decryption_request_id_++;
   DVLOG(2) << "DecryptAndDecodeAudio() - request_id " << request_id;
 
   PP_EncryptedBlockInfo block_info = {};
   if (!MakeEncryptedBlockInfo(encrypted_buffer, request_id, &block_info)) {
     return false;
   }
 
@@ skipping 20 matching lines @@
   // |video_input_resource_| is not being used by the plugin now
   // because there is only one pending video decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(media::Decryptor::kVideo, encrypted_buffer,
                                &encrypted_resource)) {
     return false;
   }
 
   // The resource should not be 0 for non-EOS buffer.
-  if (!encrypted_buffer->IsEndOfStream() && !encrypted_resource.get())
+  if (!encrypted_buffer->is_end_of_stream() && !encrypted_resource.get())
     return false;
 
   const uint32_t request_id = next_decryption_request_id_++;
   DVLOG(2) << "DecryptAndDecodeVideo() - request_id " << request_id;
   TRACE_EVENT_ASYNC_BEGIN0(
       "eme", "ContentDecryptorDelegate::DecryptAndDecodeVideo", request_id);
 
   PP_EncryptedBlockInfo block_info = {};
   if (!MakeEncryptedBlockInfo(encrypted_buffer, request_id, &block_info)) {
     return false;
@@ skipping 160 matching lines @@
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size() ||
       mapper.size() < block_info->data_size) {
     decrypt_cb.Run(media::Decryptor::kError, NULL);
     return;
   }
 
   // TODO(tomfinegan): Find a way to take ownership of the shared memory
   // managed by the PPB_Buffer_Dev, and avoid the extra copy.
   scoped_refptr<media::DecoderBuffer> decrypted_buffer(
-      media::DecoderBuffer::CopyFrom(static_cast<uint8*>(mapper.data()),
+      media::DecoderBuffer::copy_from(static_cast<uint8*>(mapper.data()),
                                      block_info->data_size));
-  decrypted_buffer->SetTimestamp(
+  decrypted_buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(block_info->tracking_info.timestamp));
   decrypt_cb.Run(media::Decryptor::kSuccess, decrypted_buffer);
 }
 
 // Use a non-class-member function here so that if for some reason
 // ContentDecryptorDelegate is destroyed before VideoFrame calls this callback,
 // we can still get the shared memory unmapped.
 static void BufferNoLongerNeeded(
     const scoped_refptr<PPB_Buffer_Impl>& ppb_buffer,
     base::Closure buffer_no_longer_needed_cb) {
@@ skipping 153 matching lines @@
   }
 }
 
 bool ContentDecryptorDelegate::MakeMediaBufferResource(
     media::Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     scoped_refptr<PPB_Buffer_Impl>* resource) {
   TRACE_EVENT0("eme", "ContentDecryptorDelegate::MakeMediaBufferResource");
 
   // End of stream buffers are represented as null resources.
-  if (encrypted_buffer->IsEndOfStream()) {
+  if (encrypted_buffer->is_end_of_stream()) {
     *resource = NULL;
     return true;
   }
 
   DCHECK(stream_type == media::Decryptor::kAudio ||
          stream_type == media::Decryptor::kVideo);
   scoped_refptr<PPB_Buffer_Impl>& media_resource =
       (stream_type == media::Decryptor::kAudio) ? audio_input_resource_
                                                 : video_input_resource_;
 
-  const size_t data_size = static_cast<size_t>(encrypted_buffer->GetDataSize());
+  const size_t data_size = static_cast<size_t>(encrypted_buffer->get_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;
     uint32_t media_resource_size =
         media_resource.get() ? media_resource->size() : kMinimumMediaBufferSize;
     while (media_resource_size < data_size) media_resource_size *= 2;
 
     DVLOG(2) << "Size of media buffer for "
              << ((stream_type == media::Decryptor::kAudio) ? "audio" : "video")
              << " stream bumped to " << media_resource_size
              << " bytes to fit input.";
     media_resource =
         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->GetData(), data_size);
+  memcpy(mapper.data(), encrypted_buffer->get_data(), data_size);
 
   *resource = media_resource;
   return true;
 }
 
 void ContentDecryptorDelegate::FreeBuffer(uint32_t buffer_id) {
   if (buffer_id) free_buffers_.push(buffer_id);
 }
 
 void ContentDecryptorDelegate::SetBufferToFreeInTrackingInfo(
     PP_DecryptTrackingInfo* tracking_info) {
   DCHECK_EQ(tracking_info->buffer_id, 0u);
 
   if (free_buffers_.empty()) return;
 
   tracking_info->buffer_id = free_buffers_.front();
   free_buffers_.pop();
 }
 
 }  // namespace ppapi
 }  // namespace webkit