Rename get_splice_buffers() to splice_buffers() per style.

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 17 matching lines @@
 static bool AllowSameTimestamp(
     bool prev_is_keyframe, bool current_is_keyframe,
     SourceBufferStream::Type type) {
   return prev_is_keyframe || !current_is_keyframe;
 }
 
 // Returns the config ID of |buffer| if |buffer| has no splice buffers or
 // |index| is out of range.  Otherwise returns the config ID for the fade out
 // preroll buffer at position |index|.
 static int GetConfigId(StreamParserBuffer* buffer, size_t index) {
-  return index < buffer->get_splice_buffers().size()
-             ? buffer->get_splice_buffers()[index]->GetConfigId()
+  return index < buffer->splice_buffers().size()
+             ? buffer->splice_buffers()[index]->GetConfigId()
              : buffer->GetConfigId();
 }
 
 // Helper class representing a range of buffered data. All buffers in a
 // SourceBufferRange are ordered sequentially in presentation order with no
 // gaps.
 class SourceBufferRange {
  public:
   // Returns the maximum distance in time between any buffer seen in this
   // stream. Used to estimate the duration of a buffer if its duration is not
@@ skipping 943 matching lines @@
   // Make the delete range exclusive if we are dealing with an allowed same
   // timestamp situation. This prevents the first buffer in the current append
   // from deleting the last buffer in the previous append if both buffers
   // have the same timestamp.
   //
   // The delete range should never be exclusive if a splice frame was generated
   // because we don't generate splice frames for same timestamp situations.
   DCHECK(new_buffers.front()->splice_timestamp() !=
          new_buffers.front()->timestamp());
   const bool is_exclusive =
-      new_buffers.front()->get_splice_buffers().empty() &&
+      new_buffers.front()->splice_buffers().empty() &&
       prev_timestamp == next_timestamp &&
       AllowSameTimestamp(prev_is_keyframe, next_is_keyframe, GetType());
 
   // Delete the buffers that |new_buffers| overlaps.
   base::TimeDelta start = new_buffers.front()->GetDecodeTimestamp();
   base::TimeDelta end = new_buffers.back()->GetDecodeTimestamp();
   base::TimeDelta duration = new_buffers.back()->duration();
 
   if (duration != kNoTimestamp() && duration > base::TimeDelta()) {
     end += duration;
@@ skipping 120 matching lines @@
 }
 
 SourceBufferStream::Status SourceBufferStream::GetNextBuffer(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
   if (!splice_buffer_) {
     const SourceBufferStream::Status status = GetNextBufferInternal(out_buffer);
 
     // Just return if GetNextBufferInternal() failed or there's no fade out
     // preroll, there's nothing else to do.
     if (status != SourceBufferStream::kSuccess ||
-        (*out_buffer)->get_splice_buffers().empty()) {
+        (*out_buffer)->splice_buffers().empty()) {
       return status;
     }
 
     // Fall through into splice buffer processing.
     splice_buffers_index_ = 0;
     splice_buffer_.swap(*out_buffer);
   }
 
   DCHECK(splice_buffer_);
-  const BufferQueue& splice_buffers = splice_buffer_->get_splice_buffers();
+  const BufferQueue& splice_buffers = splice_buffer_->splice_buffers();
   const size_t last_splice_buffer_index = splice_buffers.size() - 1;
 
   // Are there any splice buffers left to hand out?  The last buffer should be
   // handed out separately since it represents the first post-splice buffer.
   if (splice_buffers_index_ < last_splice_buffer_index) {
     // Account for config changes which occur between fade out buffers.
     if (current_config_index_ !=
         splice_buffers[splice_buffers_index_]->GetConfigId()) {
       config_change_pending_ = true;
       DVLOG(1) << "Config change (splice buffer config ID does not match).";
@@ skipping 468 matching lines @@
   // not generate splice frames in this case.
   //
   // We also do not want to generate splices if the first new buffer replaces an
   // existing buffer exactly.
   if (pre_splice_buffers.front()->timestamp() >= splice_timestamp)
     return;
 
   // If any |pre_splice_buffers| are already splices, do not generate a splice.
   for (size_t i = 0; i < pre_splice_buffers.size(); ++i) {
     const BufferQueue& original_splice_buffers =
-        pre_splice_buffers[i]->get_splice_buffers();
+        pre_splice_buffers[i]->splice_buffers();
     if (!original_splice_buffers.empty()) {
       DVLOG(1) << "Can't generate splice: overlapped buffers contain a "
                   "pre-existing splice.";
       return;
     }
   }
 
   // Don't generate splice frames which represent less than two frames, since we
   // need at least that much to generate a crossfade.  Per the spec, make this
   // check using the sample rate of the overlapping buffers.
@@ skipping 537 matching lines @@
     if (buffer->end_of_stream() || buffer->timestamp() >= end)
       break;
     if (buffer->timestamp() + buffer->duration() <= start)
       continue;
     buffers->push_back(buffer);
   }
   return previous_size < buffers->size();
 }
 
 }  // namespace media