Move VideoDecoder out of media pipeline.

media/filters/video_renderer_base.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
@@ skipping 43 matching lines @@
 void VideoRendererBase::Flush(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_cb_ = callback;
   state_ = kFlushing;
 
   AttemptFlush_Locked();
 }
 
 void VideoRendererBase::Stop(const base::Closure& callback) {
+  if (state_ == kStopped) {
+    callback.Run();
+    return;
+  }
+
   base::PlatformThreadHandle thread_to_join = base::kNullThreadHandle;
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
 
     statistics_cb_.Reset();
     time_cb_.Reset();
     if (!pending_paint_ && !pending_paint_with_last_available_)
       DoStopOrError_Locked();
 
     // Clean up our thread if present.
     if (thread_ != base::kNullThreadHandle) {
       // Signal the thread since it's possible to get stopped with the video
       // thread waiting for a read to complete.
       frame_available_.Signal();
       thread_to_join = thread_;
       thread_ = base::kNullThreadHandle;
     }
   }
   if (thread_to_join != base::kNullThreadHandle)
     base::PlatformThread::Join(thread_to_join);
 
-  callback.Run();
+  decoder_->Stop(callback);
 }
 
 void VideoRendererBase::SetPlaybackRate(float playback_rate) {
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
 void VideoRendererBase::Seek(base::TimeDelta time, const PipelineStatusCB& cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed) << "Must flush prior to seeking.";
   DCHECK(!cb.is_null());
   DCHECK(seek_cb_.is_null());
 
   state_ = kSeeking;
   seek_cb_ = cb;
   seek_timestamp_ = time;
   AttemptRead_Locked();
 }
 
-void VideoRendererBase::Initialize(VideoDecoder* decoder,
+void VideoRendererBase::Initialize(const scoped_refptr<VideoDecoder>& decoder,
                                    const PipelineStatusCB& status_cb,
                                    const StatisticsCB& statistics_cb,
                                    const TimeCB& time_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK(decoder);
   DCHECK(!status_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
@@ skipping 333 matching lines @@
 void VideoRendererBase::AttemptFlush_Locked() {
   lock_.AssertAcquired();
   DCHECK_EQ(kFlushing, state_);
 
   // Get rid of any ready frames.
   ready_frames_.clear();
 
   if (!pending_paint_ && !pending_read_) {
     state_ = kFlushed;
     current_frame_ = NULL;
-    ResetAndRunCB(&flush_cb_);
+
+    base::Closure flush_cb = flush_cb_;
+    flush_cb_.Reset();
+    decoder_->Flush(flush_cb);
   }
 }
 
 base::TimeDelta VideoRendererBase::CalculateSleepDuration(
     const scoped_refptr<VideoFrame>& next_frame,
     float playback_rate) {
   // Determine the current and next presentation timestamps.
   base::TimeDelta now = host()->GetTime();
   base::TimeDelta this_pts = current_frame_->GetTimestamp();
   base::TimeDelta next_pts;
@@ skipping 20 matching lines @@
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media