Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/gpu_video_decoder.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/filters/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop.h"
@@ skipping 383 matching lines @@
   }
 
   // VideoFrameStream ensures no kConfigChanged is passed to VideoDecoders.
   DCHECK_EQ(status, DemuxerStream::kOk) << status;
 
   if (!vda_) {
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
     return;
   }
 
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     if (state_ == kNormal) {
       state_ = kDrainingDecoder;
       vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
           &VideoDecodeAccelerator::Flush, weak_vda_));
     }
     return;
   }
 
   if (!pending_reset_cb_.is_null())
     return;
 
-  size_t size = buffer->GetDataSize();
+  size_t size = buffer->data_size();
   SHMBuffer* shm_buffer = GetSHM(size);
   if (!shm_buffer)
     return;
 
-  memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
+  memcpy(shm_buffer->shm->memory(), buffer->data(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferData(bitstream_buffer, *buffer.get());
 
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
 
   if (CanMoreDecodeWorkBeDone()) {
     // Force post here to prevent reentrancy into DemuxerStream.
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::EnsureDemuxOrDecode, weak_this_));
   }
 }
 
 void GpuVideoDecoder::RecordBufferData(
     const BitstreamBuffer& bitstream_buffer, const DecoderBuffer& buffer) {
   input_buffer_data_.push_front(BufferData(
-      bitstream_buffer.id(), buffer.GetTimestamp(),
+      bitstream_buffer.id(), buffer.timestamp(),
       demuxer_stream_->video_decoder_config().visible_rect(),
       demuxer_stream_->video_decoder_config().natural_size()));
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
   // using too-high a value is low (192 bits per extra slot).
   static const size_t kMaxInputBufferDataSize = 128;
   // Pop from the back of the list, because that's the oldest and least likely
   // to be useful in the future data.
   if (input_buffer_data_.size() > kMaxInputBufferDataSize)
     input_buffer_data_.pop_back();
@@ skipping 212 matching lines @@
   std::map<int32, BufferPair>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   PutSHM(it->second.shm_buffer);
   const scoped_refptr<DecoderBuffer>& buffer = it->second.buffer;
-  if (buffer->GetDataSize()) {
+  if (buffer->data_size()) {
     PipelineStatistics statistics;
-    statistics.video_bytes_decoded = buffer->GetDataSize();
+    statistics.video_bytes_decoded = buffer->data_size();
     statistics_cb_.Run(statistics);
   }
   bitstream_buffers_in_decoder_.erase(it);
 
   if (pending_reset_cb_.is_null() && state_ != kDrainingDecoder &&
       CanMoreDecodeWorkBeDone()) {
     EnsureDemuxOrDecode();
   }
 }
 
@@ skipping 62 matching lines @@
 
   state_ = kError;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media