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 34 matching lines @@
 void VideoRendererBase::Pause(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   state_ = kPaused;
   callback.Run();
 }
 
 void VideoRendererBase::Flush(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_callback_ = callback;

[Ami GONE FROM CHROMIUM, 2012/03/14 20:05:01]

I'm surprised you didn't rename this :)

[xhwang, 2012/03/14 22:28:41]

Doh! Done. Probably rename all seek_callback, play_callback, etc in another CL
to avoid this CL being buried in renames. Thanks!

   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();
     video_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 FilterStatusCB& 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& pipeline_status_cb,
                                    const StatisticsCB& statistics_cb,
                                    const VideoTimeCB& video_time_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK(decoder);
   DCHECK(!pipeline_status_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!video_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
@@ skipping 330 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_callback_);
+    decoder_->Flush(flush_callback_);

[Ami GONE FROM CHROMIUM, 2012/03/14 20:05:01]

This change is unsafe if flushing the decoder causes the renderer to get flushed
again (the basic reason why ResetAndRunCB() isn't RunAndResetCB()).
The right way to do this is 
base::Closure flush_cb = flush_callback_;
flush_callback_.Reset();
decoder_->Flush(flush_cb);

[xhwang, 2012/03/14 22:28:41]

Done.

+    flush_callback_.Reset();
   }
 }
 
 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