Allow Preroll() call on VideoRendererImpl without a Flush().

media/filters/video_renderer_impl.cc

Index: media/filters/video_renderer_impl.cc
diff --git a/media/filters/video_renderer_impl.cc b/media/filters/video_renderer_impl.cc
index 531c1731059ad124bd367eedd3083549bbb5fdd6..8a8b9e704d90941d16ec6773431251471bf4d9be 100644
--- a/media/filters/video_renderer_impl.cc
+++ b/media/filters/video_renderer_impl.cc
@@ -128,13 +128,27 @@ void VideoRendererImpl::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
-  DCHECK_EQ(state_, kFlushed) << "Must flush prior to prerolling.";
   DCHECK(!cb.is_null());
   DCHECK(preroll_cb_.is_null());
 
+  if (state_ == kFlushed) {
+    DCHECK(time != kNoTimestamp());
+    DCHECK(!pending_read_);
+    DCHECK(ready_frames_.empty());
+  } else {
+    DCHECK_EQ(state_, kPaused) << "state_ " << state_;

[xhwang, 2013/11/27 21:22:10]

How about 

DCHECK(state_ == kFlushed || state_ == kPaused) << state_;

on line 133 to emphasis that we only allow preroll in these two states? Then we
don't need this DCHECK here.

[acolwell GONE FROM CHROMIUM, 2013/12/02 23:17:43]

Done.

+    DCHECK(time == kNoTimestamp());
+  }
+
   state_ = kPrerolling;
   preroll_cb_ = cb;
   preroll_timestamp_ = time;
+
+  if (ShouldTransitionToPrerolled_Locked()) {
+    TransitionToPrerolled_Locked();
+    return;
+  }
+
   AttemptRead_Locked();
 }
 
@@ -388,18 +402,15 @@ void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
 
   // Maintain the latest frame decoded so the correct frame is displayed after
   // prerolling has completed.
-  if (state_ == kPrerolling && frame->GetTimestamp() <= preroll_timestamp_) {
+  if (state_ == kPrerolling && preroll_timestamp_ != kNoTimestamp() &&
+      frame->GetTimestamp() <= preroll_timestamp_) {
     ready_frames_.clear();
   }
 
   AddReadyFrame_Locked(frame);
 
-  if (state_ == kPrerolling) {
-    if (!video_frame_stream_.CanReadWithoutStalling() ||
-        ready_frames_.size() >= static_cast<size_t>(limits::kMaxVideoFrames)) {
-      TransitionToPrerolled_Locked();
-    }
-  }
+  if (ShouldTransitionToPrerolled_Locked())
+    TransitionToPrerolled_Locked();
 
   // Always request more decoded video if we have capacity. This serves two
   // purposes:
@@ -408,6 +419,12 @@ void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
   AttemptRead_Locked();
 }
 
+bool VideoRendererImpl::ShouldTransitionToPrerolled_Locked() {
+  return state_ == kPrerolling &&
+      (!video_frame_stream_.CanReadWithoutStalling() ||
+       ready_frames_.size() >= static_cast<size_t>(limits::kMaxVideoFrames));
+}
+
 void VideoRendererImpl::AddReadyFrame_Locked(
     const scoped_refptr<VideoFrame>& frame) {
   lock_.AssertAcquired();