Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/ffmpeg_demuxer.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/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 105 matching lines @@
   uint8* side_data = av_packet_get_side_data(
       packet.get(),
       AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
       &side_data_size);
 
   // If a packet is returned by FFmpeg's av_parser_parse2() the packet will
   // reference inner memory of FFmpeg.  As such we should transfer the packet
   // into memory we control.
   scoped_refptr<DecoderBuffer> buffer;
   if (side_data_size > 0) {
-    buffer = DecoderBuffer::CopyFrom(packet.get()->data, packet.get()->size,
+    buffer = DecoderBuffer::copy_from(packet.get()->data, packet.get()->size,
                                      side_data, side_data_size);
   } else {
-    buffer = DecoderBuffer::CopyFrom(packet.get()->data, packet.get()->size);
+    buffer = DecoderBuffer::copy_from(packet.get()->data, packet.get()->size);
   }
 
   if ((type() == DemuxerStream::AUDIO && audio_config_.is_encrypted()) ||
       (type() == DemuxerStream::VIDEO && video_config_.is_encrypted())) {
     scoped_ptr<DecryptConfig> config(WebMCreateDecryptConfig(
         packet->data,  packet->size,
         reinterpret_cast<const uint8*>(encryption_key_id_.data()),
         encryption_key_id_.size()));
     if (!config)
       LOG(ERROR) << "Creation of DecryptConfig failed.";
     buffer->SetDecryptConfig(config.Pass());
   }
 
-  buffer->SetTimestamp(ConvertStreamTimestamp(
+  buffer->set_timestamp(ConvertStreamTimestamp(
       stream_->time_base, packet->pts));
-  buffer->SetDuration(ConvertStreamTimestamp(
+  buffer->set_duration(ConvertStreamTimestamp(
       stream_->time_base, packet->duration));
-  if (buffer->GetTimestamp() != kNoTimestamp() &&
+  if (buffer->get_timestamp() != kNoTimestamp() &&
       last_packet_timestamp_ != kNoTimestamp() &&
-      last_packet_timestamp_ < buffer->GetTimestamp()) {
-    buffered_ranges_.Add(last_packet_timestamp_, buffer->GetTimestamp());
+      last_packet_timestamp_ < buffer->get_timestamp()) {
+    buffered_ranges_.Add(last_packet_timestamp_, buffer->get_timestamp());
     demuxer_->NotifyBufferingChanged();
   }
-  last_packet_timestamp_ = buffer->GetTimestamp();
+  last_packet_timestamp_ = buffer->get_timestamp();
 
   buffer_queue_.Push(buffer);
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::SetEndOfStream() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   end_of_stream_ = true;
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::FlushBuffers() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(read_cb_.is_null()) << "There should be no pending read";
   buffer_queue_.Clear();
   end_of_stream_ = false;
   last_packet_timestamp_ = kNoTimestamp();
 }
 
 void FFmpegDemuxerStream::Stop() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   buffer_queue_.Clear();
   if (!read_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(
-        DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
+        DemuxerStream::kOk, DecoderBuffer::create_eos_buffer());
   }
   demuxer_ = NULL;
   stream_ = NULL;
   end_of_stream_ = true;
 }
 
 base::TimeDelta FFmpegDemuxerStream::duration() {
   return duration_;
 }
 
 DemuxerStream::Type FFmpegDemuxerStream::type() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   return type_;
 }
 
 void FFmpegDemuxerStream::Read(const ReadCB& read_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   CHECK(read_cb_.is_null()) << "Overlapping reads are not supported";
   read_cb_ = BindToCurrentLoop(read_cb);
 
   // Don't accept any additional reads if we've been told to stop.
   // The |demuxer_| may have been destroyed in the pipeline thread.
   //
   // TODO(scherkus): it would be cleaner to reply with an error message.
   if (!demuxer_) {
     base::ResetAndReturn(&read_cb_).Run(
-        DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
+        DemuxerStream::kOk, DecoderBuffer::create_eos_buffer());
     return;
   }
 
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::EnableBitstreamConverter() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   CHECK(bitstream_converter_.get());
   bitstream_converter_enabled_ = true;
@@ skipping 26 matching lines @@
 }
 
 void FFmpegDemuxerStream::SatisfyPendingRead() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!read_cb_.is_null()) {
     if (!buffer_queue_.IsEmpty()) {
       base::ResetAndReturn(&read_cb_).Run(
           DemuxerStream::kOk, buffer_queue_.Pop());
     } else if (end_of_stream_) {
       base::ResetAndReturn(&read_cb_).Run(
-          DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
+          DemuxerStream::kOk, DecoderBuffer::create_eos_buffer());
     }
   }
 
   // Have capacity? Ask for more!
   if (HasAvailableCapacity() && !end_of_stream_) {
     demuxer_->NotifyCapacityAvailable();
   }
 }
 
 bool FFmpegDemuxerStream::HasAvailableCapacity() {
@@ skipping 511 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media