Refactored DataBuffer to use unix_hacker style methods.

media/filters/audio_renderer_impl.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/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 338 matching lines @@
     need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());
 
   if (!need_another_buffer && !CanRead_Locked())
     return;
 
   AttemptRead_Locked();
 }
 
 bool AudioRendererImpl::HandleSplicerBuffer(
     const scoped_refptr<DataBuffer>& buffer) {
-  if (buffer->IsEndOfStream()) {
+  if (buffer->end_of_stream()) {
     received_end_of_stream_ = true;
 
     // Transition to kPlaying if we are currently handling an underflow since
     // no more data will be arriving.
     if (state_ == kUnderflow || state_ == kRebuffering)
       state_ = kPlaying;
   }
 
   switch (state_) {
     case kUninitialized:
       NOTREACHED();
       return false;
     case kPaused:
-      if (!buffer->IsEndOfStream())
+      if (!buffer->end_of_stream())
         algorithm_->EnqueueBuffer(buffer);
       DCHECK(!pending_read_);
       base::ResetAndReturn(&pause_cb_).Run();
       return false;
     case kPrerolling:
       if (IsBeforePrerollTime(buffer))
         return true;
 
-      if (!buffer->IsEndOfStream()) {
+      if (!buffer->end_of_stream()) {
         algorithm_->EnqueueBuffer(buffer);
         if (!algorithm_->IsQueueFull())
           return false;
       }
       state_ = kPaused;
       base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
       return false;
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
-      if (!buffer->IsEndOfStream())
+      if (!buffer->end_of_stream())
         algorithm_->EnqueueBuffer(buffer);
       return false;
     case kStopped:
       return false;
   }
   return false;
 }
 
 void AudioRendererImpl::AttemptRead() {
   base::AutoLock auto_lock(lock_);
@@ skipping 44 matching lines @@
     DoPlay();
   else if (current_playback_rate != 0 && playback_rate == 0)
     DoPause();
 
   base::AutoLock auto_lock(lock_);
   algorithm_->SetPlaybackRate(playback_rate);
 }
 
 bool AudioRendererImpl::IsBeforePrerollTime(
     const scoped_refptr<DataBuffer>& buffer) {
-  return (state_ == kPrerolling) && buffer.get() && !buffer->IsEndOfStream() &&
-         (buffer->GetTimestamp() + buffer->GetDuration()) < preroll_timestamp_;
+  return (state_ == kPrerolling) && buffer.get() && !buffer->end_of_stream() &&
+         (buffer->timestamp() + buffer->duration()) < preroll_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
   if (actual_frames_per_buffer_ != audio_bus->frames()) {
     audio_buffer_.reset(
         new uint8[audio_bus->frames() * audio_parameters_.GetBytesPerFrame()]);
     actual_frames_per_buffer_ = audio_bus->frames();
   }
 
@@ skipping 172 matching lines @@
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media