Refactored DataBuffer to use unix_hacker style methods.

media/base/audio_splicer.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/base/audio_splicer.h"
 
 #include <cstdlib>
 
 #include "base/logging.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 18 matching lines @@
 AudioSplicer::~AudioSplicer() {
 }
 
 void AudioSplicer::Reset() {
   output_timestamp_helper_.SetBaseTimestamp(kNoTimestamp());
   output_buffers_.clear();
   received_end_of_stream_ = false;
 }
 
 bool AudioSplicer::AddInput(const scoped_refptr<DataBuffer>& input){
-  DCHECK(!received_end_of_stream_ || input->IsEndOfStream());
+  DCHECK(!received_end_of_stream_ || input->end_of_stream());
 
-  if (input->IsEndOfStream()) {
+  if (input->end_of_stream()) {
     output_buffers_.push_back(input);
     received_end_of_stream_ = true;
     return true;
   }
 
-  DCHECK(input->GetTimestamp() != kNoTimestamp());
-  DCHECK(input->GetDuration() > base::TimeDelta());
-  DCHECK_GT(input->GetDataSize(), 0);
+  DCHECK(input->timestamp() != kNoTimestamp());
+  DCHECK(input->duration() > base::TimeDelta());
+  DCHECK_GT(input->data_size(), 0);
 
   if (output_timestamp_helper_.base_timestamp() == kNoTimestamp())
-    output_timestamp_helper_.SetBaseTimestamp(input->GetTimestamp());
+    output_timestamp_helper_.SetBaseTimestamp(input->timestamp());
 
-  if (output_timestamp_helper_.base_timestamp() > input->GetTimestamp()) {
+  if (output_timestamp_helper_.base_timestamp() > input->timestamp()) {
     DVLOG(1) << "Input timestamp is before the base timestamp.";
     return false;
   }
 
-  base::TimeDelta timestamp = input->GetTimestamp();
+  base::TimeDelta timestamp = input->timestamp();
   base::TimeDelta expected_timestamp = output_timestamp_helper_.GetTimestamp();
   base::TimeDelta delta = timestamp - expected_timestamp;
 
   if (std::abs(delta.InMilliseconds()) > kMaxTimeDeltaInMilliseconds) {
     DVLOG(1) << "Timestamp delta too large: " << delta.InMicroseconds() << "us";
     return false;
   }
 
   int bytes_to_fill = 0;
   if (delta != base::TimeDelta())
     bytes_to_fill = output_timestamp_helper_.GetBytesToTarget(timestamp);
 
   if (bytes_to_fill == 0 || std::abs(bytes_to_fill) < min_gap_size_) {
     AddOutputBuffer(input);
     return true;
   }
 
   if (bytes_to_fill > 0) {
     DVLOG(1) << "Gap detected @ " << expected_timestamp.InMicroseconds()
              << " us: " << delta.InMicroseconds() << " us";
 
     // Create a buffer with enough silence samples to fill the gap and
     // add it to the output buffer.
     scoped_refptr<DataBuffer> gap = new DataBuffer(bytes_to_fill);
-    gap->SetDataSize(bytes_to_fill);
-    memset(gap->GetWritableData(), 0, bytes_to_fill);
-    gap->SetTimestamp(expected_timestamp);
-    gap->SetDuration(output_timestamp_helper_.GetDuration(bytes_to_fill));
+    gap->set_data_size(bytes_to_fill);
+    memset(gap->writable_data(), 0, bytes_to_fill);
+    gap->set_timestamp(expected_timestamp);
+    gap->set_duration(output_timestamp_helper_.GetDuration(bytes_to_fill));
     AddOutputBuffer(gap);
 
     // Add the input buffer now that the gap has been filled.
     AddOutputBuffer(input);
     return true;
   }
 
   int bytes_to_skip = -bytes_to_fill;
 
   DVLOG(1) << "Overlap detected @ " << expected_timestamp.InMicroseconds()
            << " us: "  << -delta.InMicroseconds() << " us";
 
-  if (input->GetDataSize() <= bytes_to_skip) {
+  if (input->data_size() <= bytes_to_skip) {
     DVLOG(1) << "Dropping whole buffer";
     return true;
   }
 
   // Copy the trailing samples that do not overlap samples already output
   // into a new buffer. Add this new buffer to the output queue.
   //
   // TODO(acolwell): Implement a cross-fade here so the transition is less
   // jarring.
-  int new_buffer_size = input->GetDataSize() - bytes_to_skip;
+  int new_buffer_size = input->data_size() - bytes_to_skip;
 
   scoped_refptr<DataBuffer> new_buffer = new DataBuffer(new_buffer_size);
-  new_buffer->SetDataSize(new_buffer_size);
-  memcpy(new_buffer->GetWritableData(),
-         input->GetData() + bytes_to_skip,
+  new_buffer->set_data_size(new_buffer_size);
+  memcpy(new_buffer->writable_data(),
+         input->data() + bytes_to_skip,
          new_buffer_size);
-  new_buffer->SetTimestamp(expected_timestamp);
-  new_buffer->SetDuration(
+  new_buffer->set_timestamp(expected_timestamp);
+  new_buffer->set_duration(
       output_timestamp_helper_.GetDuration(new_buffer_size));
   AddOutputBuffer(new_buffer);
   return true;
 }
 
 bool AudioSplicer::HasNextBuffer() const {
   return !output_buffers_.empty();
 }
 
 scoped_refptr<DataBuffer> AudioSplicer::GetNextBuffer() {
   scoped_refptr<DataBuffer> ret = output_buffers_.front();
   output_buffers_.pop_front();
   return ret;
 }
 
 void AudioSplicer::AddOutputBuffer(const scoped_refptr<DataBuffer>& buffer) {
-  output_timestamp_helper_.AddBytes(buffer->GetDataSize());
+  output_timestamp_helper_.AddBytes(buffer->data_size());
   output_buffers_.push_back(buffer);
 }
 
 }  // namespace media