Convert Filter::Seek() to use new callback system.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2011 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 "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
@@ skipping 295 matching lines @@
 
 void FFmpegDemuxer::Stop(FilterCallback* callback) {
   // Post a task to notify the streams to stop as well.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::StopTask, callback));
 
   // Then wakes up the thread from reading.
   SignalReadCompleted(DataSource::kReadError);
 }
 
-void FFmpegDemuxer::Seek(base::TimeDelta time, FilterCallback* callback) {
+void FFmpegDemuxer::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
   // TODO(hclam): by returning from this method, it is assumed that the seek
   // operation is completed and filters behind the demuxer is good to issue
   // more reads, but we are posting a task here, which makes the seek operation
   // asynchronous, should change how seek works to make it fully asynchronous.
   message_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &FFmpegDemuxer::SeekTask, time, callback));
+      NewRunnableMethod(this, &FFmpegDemuxer::SeekTask, time, cb));
 }
 
 void FFmpegDemuxer::SetPlaybackRate(float playback_rate) {
   DCHECK(data_source_.get());
   data_source_->SetPlaybackRate(playback_rate);
 }
 
 void FFmpegDemuxer::SetPreload(Preload preload) {
   DCHECK(data_source_.get());
   data_source_->SetPreload(preload);
@@ skipping 188 matching lines @@
         Limits::kMaxTimeInMicroseconds);
   }
 
   // Good to go: set the duration and notify we're done initializing.
   if (host())
     host()->SetDuration(max_duration);
   max_duration_ = max_duration;
   callback->Run(PIPELINE_OK);
 }
 
-void FFmpegDemuxer::SeekTask(base::TimeDelta time, FilterCallback* callback) {
+void FFmpegDemuxer::SeekTask(base::TimeDelta time, const FilterStatusCB& cb) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  scoped_ptr<FilterCallback> c(callback);
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter)
       (*iter)->FlushBuffers();
   }
 
   // Always seek to a timestamp less than or equal to the desired timestamp.
   int flags = AVSEEK_FLAG_BACKWARD;
 
   // Passing -1 as our stream index lets FFmpeg pick a default stream.  FFmpeg
   // will attempt to use the lowest-index video stream, if present, followed by
   // the lowest-index audio stream.
   if (av_seek_frame(format_context_, -1, time.InMicroseconds(), flags) < 0) {
     // Use VLOG(1) instead of NOTIMPLEMENTED() to prevent the message being
     // captured from stdout and contaminates testing.
     // TODO(scherkus): Implement this properly and signal error (BUG=23447).
     VLOG(1) << "Not implemented";
   }
 
   // Notify we're finished seeking.
-  callback->Run();
+  cb.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::DemuxTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
     return;
   }
 
@@ skipping 105 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media