Remove MessageLoop methods from Filter interface

media/filters/decoder_base.h

 // Copyright (c) 2010 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.
 
 // A base class that provides the plumbing for a decoder filters.
 
 #ifndef MEDIA_FILTERS_DECODER_BASE_H_
 #define MEDIA_FILTERS_DECODER_BASE_H_
 
 #include <deque>
 
 #include "base/callback.h"
 #include "base/stl_util-inl.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "media/base/buffers.h"
 #include "media/base/callback.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 
 namespace media {
 
 // In this class, we over-specify method lookup via this-> to avoid unexpected
 // name resolution issues due to the two-phase lookup needed for dependent
 // name resolution in templates.
 template <class Decoder, class Output>
 class DecoderBase : public Decoder {
  public:
-
   // Filter implementation.
   virtual void Stop(FilterCallback* callback) {
     this->message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &DecoderBase::StopTask, callback));
   }
 
   virtual void Seek(base::TimeDelta time,
                     FilterCallback* callback) {
     this->message_loop()->PostTask(
@@ skipping 15 matching lines @@
   virtual const MediaFormat& media_format() { return media_format_; }
 
   // Audio decoder.
   // Note that this class is only used by the audio decoder, this will
   // eventually be merged into FFmpegAudioDecoder.
   virtual void ProduceAudioSamples(scoped_refptr<Output> output) {
     this->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &DecoderBase::ReadTask, output));
   }
 
+  MessageLoop* message_loop() { return message_loop_; }
+
  protected:
-  DecoderBase()
-      : pending_reads_(0),
+  DecoderBase(MessageLoop* message_loop)
+      : message_loop_(message_loop),
+        pending_reads_(0),
         pending_requests_(0),
         state_(kUninitialized) {
   }
 
   virtual ~DecoderBase() {
     DCHECK(state_ == kUninitialized || state_ == kStopped);
     DCHECK(result_queue_.empty());
   }
 
   // This method is called by the derived class from within the OnDecode method.
@@ skipping 189 matching lines @@
     // Execute the callback!
     --pending_requests_;
 
     // TODO(hclam): We only inherit this class from FFmpegAudioDecoder so we
     // are making this call. We should correct this by merging this class into
     // FFmpegAudioDecoder.
     Decoder::consume_audio_samples_callback()->Run(output);
     return true;
   }
 
+  MessageLoop* message_loop_;
+
   // Tracks the number of asynchronous reads issued to |demuxer_stream_|.
   // Using size_t since it is always compared against deque::size().
   size_t pending_reads_;
   // Tracks the number of asynchronous reads issued from renderer.
   size_t pending_requests_;
 
   // Pointer to the demuxer stream that will feed us compressed buffers.
   scoped_refptr<DemuxerStream> demuxer_stream_;
 
   // Queue of decoded samples produced in the OnDecode() method of the decoder.
@@ skipping 14 matching lines @@
     kStopped,
   };
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_DECODER_BASE_H_