Refactored DecoderBuffer to use unix_hacker_style naming.

media/filters/source_buffer_stream.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/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 1327 matching lines @@
 
 void SourceBufferRange::AppendBuffersToEnd(const BufferQueue& new_buffers) {
   DCHECK(buffers_.empty() ||
          buffers_.back()->GetDecodeTimestamp() <=
          new_buffers.front()->GetDecodeTimestamp());
 
   for (BufferQueue::const_iterator itr = new_buffers.begin();
        itr != new_buffers.end(); ++itr) {
     DCHECK((*itr)->GetDecodeTimestamp() != kNoTimestamp());
     buffers_.push_back(*itr);
-    size_in_bytes_ += (*itr)->GetDataSize();
+    size_in_bytes_ += (*itr)->data_size();
 
     if ((*itr)->IsKeyframe()) {
       keyframe_map_.insert(
           std::make_pair((*itr)->GetDecodeTimestamp(),
                          buffers_.size() - 1 + keyframe_map_index_base_));
     }
   }
 }
 
 void SourceBufferRange::Seek(base::TimeDelta timestamp) {
@@ skipping 136 matching lines @@
 
   // Now we need to delete all the buffers that depend on the keyframe we've
   // just deleted.
   int end_index = keyframe_map_.size() > 0 ?
       keyframe_map_.begin()->second - keyframe_map_index_base_ :
       buffers_.size();
 
   // Delete buffers from the beginning of the buffered range up until (but not
   // including) the next keyframe.
   for (int i = 0; i < end_index; i++) {
-    int bytes_deleted = buffers_.front()->GetDataSize();
+    int bytes_deleted = buffers_.front()->data_size();
     size_in_bytes_ -= bytes_deleted;
     total_bytes_deleted += bytes_deleted;
     deleted_buffers->push_back(buffers_.front());
     buffers_.pop_front();
     ++buffers_deleted;
   }
 
   // Update |keyframe_map_index_base_| to account for the deleted buffers.
   keyframe_map_index_base_ += buffers_deleted;
 
@@ skipping 19 matching lines @@
   DCHECK_GT(keyframe_map_.size(), 0u);
   --back;
 
   // The index of the first buffer in the last GOP is equal to the new size of
   // |buffers_| after that GOP is deleted.
   size_t goal_size = back->second - keyframe_map_index_base_;
   keyframe_map_.erase(back);
 
   int total_bytes_deleted = 0;
   while (buffers_.size() != goal_size) {
-    int bytes_deleted = buffers_.back()->GetDataSize();
+    int bytes_deleted = buffers_.back()->data_size();
     size_in_bytes_ -= bytes_deleted;
     total_bytes_deleted += bytes_deleted;
     // We're removing buffers from the back, so push each removed buffer to the
     // front of |deleted_buffers| so that |deleted_buffers| are in nondecreasing
     // order.
     deleted_buffers->push_front(buffers_.back());
     buffers_.pop_back();
   }
 
   return total_bytes_deleted;
@@ skipping 23 matching lines @@
   KeyframeMap::const_iterator last_gop = keyframe_map_.end();
   --last_gop;
   return last_gop->second - keyframe_map_index_base_ <= next_buffer_index_;
 }
 
 void SourceBufferRange::FreeBufferRange(
     const BufferQueue::iterator& starting_point,
     const BufferQueue::iterator& ending_point) {
   for (BufferQueue::iterator itr = starting_point;
        itr != ending_point; ++itr) {
-    size_in_bytes_ -= (*itr)->GetDataSize();
+    size_in_bytes_ -= (*itr)->data_size();
     DCHECK_GE(size_in_bytes_, 0);
   }
   buffers_.erase(starting_point, ending_point);
 }
 
 void SourceBufferRange::TruncateAt(
     const BufferQueue::iterator& starting_point, BufferQueue* removed_buffers) {
   DCHECK(!removed_buffers || removed_buffers->empty());
 
   // Return if we're not deleting anything.
@@ skipping 122 matching lines @@
   return start_timestamp;
 }
 
 base::TimeDelta SourceBufferRange::GetEndTimestamp() const {
   DCHECK(!buffers_.empty());
   return buffers_.back()->GetDecodeTimestamp();
 }
 
 base::TimeDelta SourceBufferRange::GetBufferedEndTimestamp() const {
   DCHECK(!buffers_.empty());
-  base::TimeDelta duration = buffers_.back()->GetDuration();
+  base::TimeDelta duration = buffers_.back()->duration();
   if (duration == kNoTimestamp() || duration == base::TimeDelta())
     duration = GetApproximateDuration();
   return GetEndTimestamp() + duration;
 }
 
 base::TimeDelta SourceBufferRange::NextKeyframeTimestamp(
     base::TimeDelta timestamp) {
   DCHECK(!keyframe_map_.empty());
 
   if (timestamp < GetStartTimestamp() || timestamp >= GetBufferedEndTimestamp())
@@ skipping 26 matching lines @@
   return ComputeFudgeRoom(GetApproximateDuration());
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
   DCHECK(max_interbuffer_distance != kNoTimestamp());
   return max_interbuffer_distance;
 }
 
 }  // namespace media