Add status parameter to DemuxerStream::ReadCB

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 "base/bind.h"
 #include "base/callback.h"
@@ skipping 209 matching lines @@
     return;
   sink_->SetVolume(volume);
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
-void AudioRendererImpl::DecodedAudioReady(scoped_refptr<Buffer> buffer) {
+void AudioRendererImpl::DecodedAudioReady(AudioDecoder::Status status,
+                                          const scoped_refptr<Buffer>& buffer) {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
          state_ == kUnderflow || state_ == kRebuffering || state_ == kStopped);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
-  if (buffer && buffer->IsEndOfStream()) {
+  if (status == AudioDecoder::kDecodeError) {
+    HandleDecodeError();
+    return;
+  }
+
+  if (status == AudioDecoder::kAborted) {
+    HandleAbortedRead();
+    return;
+  }
+
+  DCHECK_EQ(status, AudioDecoder::kOk);
+  DCHECK(buffer);
+
+  if (buffer->IsEndOfStream()) {
     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;
     case kPaused:
-      if (buffer && !buffer->IsEndOfStream())
+      if (!buffer->IsEndOfStream())
         algorithm_->EnqueueBuffer(buffer);
       DCHECK(!pending_read_);
       base::ResetAndReturn(&pause_cb_).Run();
       return;
     case kSeeking:
       if (IsBeforeSeekTime(buffer)) {
         ScheduleRead_Locked();
         return;
       }
-      if (buffer && !buffer->IsEndOfStream()) {
+      if (!buffer->IsEndOfStream()) {
         algorithm_->EnqueueBuffer(buffer);
         if (!algorithm_->IsQueueFull())
           return;
       }
       state_ = kPaused;
       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
       return;
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
-      if (buffer && !buffer->IsEndOfStream())
+      if (!buffer->IsEndOfStream())
         algorithm_->EnqueueBuffer(buffer);
       return;
     case kStopped:
       return;
   }
 }
 
 void AudioRendererImpl::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   if (pending_read_ || state_ == kPaused)
@@ skipping 217 matching lines @@
 
 void AudioRendererImpl::OnRenderError() {
   host()->DisableAudioRenderer();
 }
 
 void AudioRendererImpl::DisableUnderflowForTesting() {
   DCHECK(!is_initialized_);
   underflow_disabled_ = true;
 }
 
+void AudioRendererImpl::HandleDecodeError() {
+  switch (state_) {
+    case kUninitialized:
+      NOTREACHED();
+      return;
+    case kPaused:
+      base::ResetAndReturn(&pause_cb_).Run();

[Ami GONE FROM CHROMIUM, 2012/06/26 00:33:21]

does the error get dropped at this point?

[acolwell GONE FROM CHROMIUM, 2012/07/12 01:19:38]

Done.

+      return;
+    case kSeeking:
+      state_ = kPaused;
+      base::ResetAndReturn(&seek_cb_).Run(PIPELINE_ERROR_DECODE);
+      return;
+    case kPlaying:
+    case kUnderflow:
+    case kRebuffering:
+    case kStopped:
+      host()->SetError(PIPELINE_ERROR_DECODE);
+      return;
+  }
+}
+
+void AudioRendererImpl::HandleAbortedRead() {
+  switch (state_) {
+    case kUninitialized:
+      NOTREACHED();
+      return;
+    case kPaused:
+      base::ResetAndReturn(&pause_cb_).Run();
+      return;
+    case kSeeking:
+      state_ = kPaused;
+      base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
+      return;
+    case kPlaying:
+    case kUnderflow:
+    case kRebuffering:
+    case kStopped:
+      return;
+  }
+}
+
 }  // namespace media