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

media/filters/video_renderer_impl.cc

 // Copyright 2013 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 "media/filters/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 110 matching lines @@
 void VideoRendererImpl::SetPlaybackRate(float playback_rate) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
 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());
+  DCHECK(state_ == kFlushed || state_== kPaused) << "state_ " << state_;
+
+  if (state_ == kFlushed) {
+    DCHECK(time != kNoTimestamp());
+    DCHECK(!pending_read_);
+    DCHECK(ready_frames_.empty());
+  } else {
+    DCHECK(time == kNoTimestamp());
+  }
 
   state_ = kPrerolling;
   preroll_cb_ = cb;
   preroll_timestamp_ = time;
+
+  if (ShouldTransitionToPrerolled_Locked()) {
+    TransitionToPrerolled_Locked();
+    return;
+  }
+
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::Initialize(DemuxerStream* stream,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
                                    const TimeCB& max_time_cb,
                                    const NaturalSizeChangedCB& size_changed_cb,
                                    const base::Closure& ended_cb,
                                    const PipelineStatusCB& error_cb,
@@ skipping 233 matching lines @@
     max_time_cb_.Run(get_duration_cb_.Run());
 
     if (state_ == kPrerolling)
       TransitionToPrerolled_Locked();
 
     return;
   }
 
   // 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:
   //   1) Prerolling while paused
   //   2) Keeps decoding going if video rendering thread starts falling behind
   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();
   DCHECK(!frame->end_of_stream());
 
   // Adjust the incoming frame if its rendering stop time is past the duration
   // of the video itself. This is typically the last frame of the video and
   // occurs if the container specifies a duration that isn't a multiple of the
   // frame rate.  Another way for this to happen is for the container to state
   // a smaller duration than the largest packet timestamp.
@@ skipping 110 matching lines @@
     statistics_cb_.Run(statistics);
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media