Splitting media filter's Initialize() into Create() + callback and Seek() + callback.

media/filters/decoder_base.h

 // Copyright (c) 2009 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>
@@ skipping 15 matching lines @@
 class DecoderBase : public Decoder {
  public:
   typedef CallbackRunner< Tuple1<Output*> > ReadCallback;
 
   // MediaFilter implementation.
   virtual void Stop() {
     this->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &DecoderBase::StopTask));
   }
 
-  virtual void Seek(base::TimeDelta time) {
+  virtual void Seek(base::TimeDelta time,
+                    FilterCallback* callback) {
     this->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &DecoderBase::SeekTask, time));
+        NewRunnableMethod(this, &DecoderBase::SeekTask, time, callback));
   }
 
   // Decoder implementation.
-  virtual bool Initialize(DemuxerStream* demuxer_stream) {
+  virtual void Initialize(DemuxerStream* demuxer_stream,
+                          FilterCallback* callback) {
     this->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &DecoderBase::InitializeTask, demuxer_stream));
-    return true;
+        NewRunnableMethod(this, &DecoderBase::InitializeTask, demuxer_stream,
+                          callback));
   }
 
   virtual const MediaFormat& media_format() { return media_format_; }
 
   // Audio or video decoder.
   virtual void Read(ReadCallback* read_callback) {
     this->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &DecoderBase::ReadTask, read_callback));
   }
 
@@ skipping 64 matching lines @@
 
     // Delegate to the subclass first.
     OnStop();
 
     // Throw away all buffers in all queues.
     result_queue_.clear();
     STLDeleteElements(&read_queue_);
     state_ = STOPPED;
   }
 
-  void SeekTask(base::TimeDelta time) {
+  void SeekTask(base::TimeDelta time, FilterCallback* callback) {
     DCHECK_EQ(MessageLoop::current(), this->message_loop());
+    scoped_ptr<FilterCallback> c(callback);
 
     // Delegate to the subclass first.
     OnSeek(time);
 
     // Flush the result queue.
     result_queue_.clear();
 
     // Turn on the seeking flag so that we can discard buffers until a
     // discontinuous buffer is received.
     seeking_ = true;
+
+    // For now, signal that we're done seeking.
+    // TODO(scherkus): implement asynchronous seeking for decoder_base.h
+    callback->Run();
   }
 
-  void InitializeTask(DemuxerStream* demuxer_stream) {
+  void InitializeTask(DemuxerStream* demuxer_stream, FilterCallback* callback) {
     DCHECK_EQ(MessageLoop::current(), this->message_loop());
     DCHECK(state_ == UNINITIALIZED);
     DCHECK(!demuxer_stream_);
+    scoped_ptr<FilterCallback> c(callback);
     demuxer_stream_ = demuxer_stream;
 
     // Delegate to subclass first.
     if (!OnInitialize(demuxer_stream_)) {
       this->host()->Error(PIPELINE_ERROR_DECODE);
+      callback->Run();
       return;
     }
 
     // TODO(scherkus): subclass shouldn't mutate superclass media format.
     DCHECK(!media_format_.empty()) << "Subclass did not set media_format_";
     state_ = INITIALIZED;
-    this->host()->InitializationComplete();
+    callback->Run();
   }
 
   void ReadTask(ReadCallback* read_callback) {
     DCHECK_EQ(MessageLoop::current(), this->message_loop());
 
     // TODO(scherkus): should reply with a null operation (empty buffer).
     if (IsStopped()) {
       delete read_callback;
       return;
     }
@@ skipping 102 matching lines @@
     STOPPED,
   };
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_DECODER_BASE_H_