Remove AudioDecoder from the Filter heirarchy.

media/filters/ffmpeg_audio_decoder.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/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
+#include "media/base/audio_decoder.h"

[scherkus (not reviewing), 2012/02/06 21:04:04]

this is in .h

[Ami GONE FROM CHROMIUM, 2012/02/06 21:38:48]

Done.

 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/demuxer.h"
-#include "media/base/filter_host.h"
 #include "media/base/pipeline.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 
 namespace media {
 
 // Returns true if the decode result was an error.
 static bool IsErrorResult(int result, int decoded_size) {
   return result < 0 ||
       decoded_size < 0 ||
       decoded_size > AVCODEC_MAX_AUDIO_FRAME_SIZE;
@@ skipping 30 matching lines @@
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       samples_per_second_(0),
       decoded_audio_size_(AVCODEC_MAX_AUDIO_FRAME_SIZE),
       decoded_audio_(static_cast<uint8*>(av_malloc(decoded_audio_size_))) {
 }
 
 FFmpegAudioDecoder::~FFmpegAudioDecoder() {
   av_free(decoded_audio_);
 
-  // XXX: should we require Stop() to be called? this might end up getting
-  // called on a random thread due to refcounting.
+  // TODO(scherkus): should we require Stop() to be called? this might end up
+  // getting called on a random thread due to refcounting.
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
   }
 }
 
-void FFmpegAudioDecoder::Flush(const base::Closure& callback) {
-  message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FFmpegAudioDecoder::DoFlush, this, callback));
-}
-
 void FFmpegAudioDecoder::Initialize(
-    DemuxerStream* stream,
+    const scoped_refptr<DemuxerStream> stream,
     const PipelineStatusCB& callback,
     const StatisticsCallback& stats_callback) {
-  // TODO(scherkus): change Initialize() signature to pass |stream| as a
-  // scoped_refptr<>.
-  scoped_refptr<DemuxerStream> ref_stream(stream);
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FFmpegAudioDecoder::DoInitialize, this,
-                 ref_stream, callback, stats_callback));
+                 stream, callback, stats_callback));
 }
 
 void FFmpegAudioDecoder::Read(const ReadCB& callback) {
   // Complete operation asynchronously on different stack of execution as per
   // the API contract of AudioDecoder::Read()
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &FFmpegAudioDecoder::DoRead, this, callback));
 }
 
 int FFmpegAudioDecoder::bits_per_channel() {
   return bits_per_channel_;
 }
 
 ChannelLayout FFmpegAudioDecoder::channel_layout() {
   return channel_layout_;
 }
 
 int FFmpegAudioDecoder::samples_per_second() {
   return samples_per_second_;
 }
 
+void FFmpegAudioDecoder::Reset(const base::Closure& closure) {
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &FFmpegAudioDecoder::DoReset, this, closure));
+}
+
 void FFmpegAudioDecoder::DoInitialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& callback,
     const StatisticsCallback& stats_callback) {
   demuxer_stream_ = stream;
   const AudioDecoderConfig& config = stream->audio_decoder_config();
   stats_callback_ = stats_callback;
 
   // TODO(scherkus): this check should go in Pipeline prior to creating
   // decoder objects.
@@ skipping 22 matching lines @@
   }
 
   // Success!
   bits_per_channel_ = config.bits_per_channel();
   channel_layout_ = config.channel_layout();
   samples_per_second_ = config.samples_per_second();
 
   callback.Run(PIPELINE_OK);
 }
 
-void FFmpegAudioDecoder::DoFlush(const base::Closure& callback) {
+void FFmpegAudioDecoder::DoReset(const base::Closure& closure) {
   avcodec_flush_buffers(codec_context_);
   estimated_next_timestamp_ = kNoTimestamp();
-  callback.Run();
+  closure.Run();
 }
 
 void FFmpegAudioDecoder::DoRead(const ReadCB& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!callback.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
   read_cb_ = callback;
   ReadFromDemuxerStream();
 }
@@ skipping 124 matching lines @@
 }
 
 void FFmpegAudioDecoder::DeliverSamples(const scoped_refptr<Buffer>& samples) {
   // Reset the callback before running to protect against reentrancy.
   ReadCB read_cb = read_cb_;
   read_cb_.Reset();
   read_cb.Run(samples);
 }
 
 }  // namespace media