Refactored DataBuffer to use unix_hacker style methods.

media/filters/decrypting_audio_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/decrypting_audio_decoder.h"
 
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 78 matching lines @@
   DVLOG(3) << "Read()";
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(state_ == kIdle || state_ == kDecodeFinished) << state_;
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
   read_cb_ = BindToCurrentLoop(read_cb);
 
   // Return empty (end-of-stream) frames if decoding has finished.
   if (state_ == kDecodeFinished) {
-    base::ResetAndReturn(&read_cb_).Run(kOk, DataBuffer::CreateEOSBuffer());
+    base::ResetAndReturn(&read_cb_).Run(kOk, DataBuffer::create_eos_buffer());
     return;
   }
 
   if (!queued_audio_frames_.empty()) {
     base::ResetAndReturn(&read_cb_).Run(kOk, queued_audio_frames_.front());
     queued_audio_frames_.pop_front();
     return;
   }
 
   state_ = kPendingDemuxerRead;
@@ skipping 279 matching lines @@
   if (buffer_size) {
     PipelineStatistics statistics;
     statistics.audio_bytes_decoded = buffer_size;
     statistics_cb_.Run(statistics);
   }
 
   if (status == Decryptor::kNeedMoreData) {
     DVLOG(2) << "DeliverFrame() - kNeedMoreData";
     if (scoped_pending_buffer_to_decode->IsEndOfStream()) {
       state_ = kDecodeFinished;
-      base::ResetAndReturn(&read_cb_).Run(kOk, DataBuffer::CreateEOSBuffer());
+      base::ResetAndReturn(&read_cb_).Run(kOk, DataBuffer::create_eos_buffer());
       return;
     }
 
     state_ = kPendingDemuxerRead;
     ReadFromDemuxerStream();
     return;
   }
 
   DCHECK_EQ(status, Decryptor::kSuccess);
   DCHECK(!frames.empty());
@@ skipping 41 matching lines @@
 
 void DecryptingAudioDecoder::EnqueueFrames(
     const Decryptor::AudioBuffers& frames) {
   queued_audio_frames_ = frames;
 
   for (Decryptor::AudioBuffers::iterator iter = queued_audio_frames_.begin();
       iter != queued_audio_frames_.end();
       ++iter) {
     scoped_refptr<DataBuffer>& frame = *iter;
 
-    DCHECK(!frame->IsEndOfStream()) << "EOS frame returned.";
-    DCHECK_GT(frame->GetDataSize(), 0) << "Empty frame returned.";
+    DCHECK(!frame->is_end_of_stream()) << "EOS frame returned.";
+    DCHECK_GT(frame->get_data_size(), 0) << "Empty frame returned.";
 
     base::TimeDelta cur_timestamp = output_timestamp_base_ +
         NumberOfSamplesToDuration(total_samples_decoded_);
-    if (IsOutOfSync(cur_timestamp, frame->GetTimestamp())) {
+    if (IsOutOfSync(cur_timestamp, frame->get_timestamp())) {
       DVLOG(1)  << "Timestamp returned by the decoder ("
-                << frame->GetTimestamp().InMilliseconds() << " ms)"
+                << frame->get_timestamp().InMilliseconds() << " ms)"
                 << " does not match the input timestamp and number of samples"
                 << " decoded (" << cur_timestamp.InMilliseconds() << " ms).";
     }
-    frame->SetTimestamp(cur_timestamp);
+    frame->set_timestamp(cur_timestamp);
 
-    int frame_size = frame->GetDataSize();
+    int frame_size = frame->get_data_size();
     DCHECK_EQ(frame_size % bytes_per_sample_, 0) <<
         "Decoder didn't output full samples";
     int samples_decoded = frame_size / bytes_per_sample_;
     total_samples_decoded_ += samples_decoded;
 
     base::TimeDelta next_timestamp = output_timestamp_base_ +
         NumberOfSamplesToDuration(total_samples_decoded_);
     base::TimeDelta duration = next_timestamp - cur_timestamp;
-    frame->SetDuration(duration);
+    frame->set_duration(duration);
   }
 }
 
 base::TimeDelta DecryptingAudioDecoder::NumberOfSamplesToDuration(
     int number_of_samples) const {
   DCHECK(samples_per_second_);
   return base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
                                            number_of_samples /
                                            samples_per_second_);
 }
 
 }  // namespace media