Completely random typo fixes and style corrections cleanup.

media/filters/video_renderer_base.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/bind.h"
 #include "base/callback.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/callback.h"
 #include "media/base/filter_host.h"
@@ skipping 40 matching lines @@
 }
 
 void VideoRendererBase::Pause(FilterCallback* callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   AutoCallbackRunner done_runner(callback);
   state_ = kPaused;
 }
 
 void VideoRendererBase::Flush(FilterCallback* callback) {
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
-
-  base::AutoLock auto_lock(lock_);
   flush_callback_.reset(callback);
   state_ = kFlushing;
 
-  if (pending_paint_ == false)
-    FlushBuffers();
+  if (!pending_paint_)
+    FlushBuffers_Locked();
 }
 
 void VideoRendererBase::Stop(FilterCallback* callback) {
   base::PlatformThreadHandle old_thread_handle = base::kNullThreadHandle;
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
 
     if (!pending_paint_ && !pending_paint_with_last_available_)
       DoStopOrErrorFlush_Locked();
@@ skipping 22 matching lines @@
 void VideoRendererBase::Seek(base::TimeDelta time, const FilterStatusCB&  cb) {
   bool run_callback = false;
 
   {
     base::AutoLock auto_lock(lock_);
     // There is a race condition between filters to receive SeekTask().
     // It turns out we could receive buffer from decoder before seek()
     // is called on us. so we do the following:
     // kFlushed => ( Receive first buffer or Seek() ) => kSeeking and
     // kSeeking => ( Receive enough buffers) => kPrerolled. )
-    DCHECK(kPrerolled == state_ || kFlushed == state_ || kSeeking == state_);
+    DCHECK(state_ == kPrerolled || state_ == kFlushed || state_ == kSeeking);
     DCHECK(!cb.is_null());
     DCHECK(seek_cb_.is_null());
 
     if (state_ == kPrerolled) {
       // Already get enough buffers from decoder.
       run_callback = true;
 
     } else {
       // Otherwise we are either kFlushed or kSeeking, but without enough
       // buffers we should save the callback function and call it later.
@@ skipping 132 matching lines @@
       continue;
 
     scoped_refptr<VideoFrame> next_frame = frames_queue_ready_.front();
     if (next_frame->IsEndOfStream()) {
       state_ = kEnded;
       DVLOG(1) << "Video render gets EOS";
       host()->NotifyEnded();
       continue;
     }
 
-    if (next_frame->GetTimestamp() <= host()->GetTime() + kIdleTimeDelta ||
-        current_frame_.get() == NULL ||
-        current_frame_->GetTimestamp() > host()->GetDuration()) {
-      // 1. either next frame's time-stamp is already current.
-      // 2. or we do not have any current frame yet anyway.
-      // 3. or a special case when the stream is badly formatted that
-      // we get video frame with time-stamp greater than the duration.
-      // In this case we should proceed anyway and try to obtain the
-      // end-of-stream packet.
-      scoped_refptr<VideoFrame> timeout_frame;
-      bool new_frame_available = false;
-      if (!pending_paint_) {
-        // In this case, current frame could be recycled.
-        timeout_frame = current_frame_;
-        current_frame_ = frames_queue_ready_.front();
+    // Normally we're ready to loop again at this point, but there are
+    // exceptions that cause us to drop a frame and/or consider painting a
+    // "next" frame.
+    if (next_frame->GetTimestamp() > host()->GetTime() + kIdleTimeDelta &&
+        current_frame_ &&
+        current_frame_->GetTimestamp() <= host()->GetDuration()) {
+      continue;
+    }
+
+    // If we got here then:
+    // 1. next frame's timestamp is already current; or
+    // 2. we do not have any current frame yet anyway; or
+    // 3. a special case when the stream is badly formatted and
+    //    we got a frame with timestamp greater than overall duration.
+    //    In this case we should proceed anyway and try to obtain the
+    //    end-of-stream packet.
+    scoped_refptr<VideoFrame> timeout_frame;
+    bool new_frame_available = false;
+    if (!pending_paint_) {
+      // In this case, current frame could be recycled.
+      timeout_frame = current_frame_;
+      current_frame_ = frames_queue_ready_.front();
+      frames_queue_ready_.pop_front();
+      new_frame_available = true;
+    } else if (pending_paint_ && frames_queue_ready_.size() >= 2 &&
+               !frames_queue_ready_[1]->IsEndOfStream()) {
+      // Painter could be really slow, therefore we had to skip frames if
+      // 1. We had not reached end of stream.
+      // 2. The next frame of current frame is also out-dated.
+      base::TimeDelta next_remaining_time =
+          frames_queue_ready_[1]->GetTimestamp() - host()->GetTime();
+      if (next_remaining_time.InMicroseconds() <= 0) {
+        // Since the current frame is still hold by painter/compositor, and
+        // the next frame is already timed-out, we should skip the next frame
+        // which is the first frame in the queue.
+        timeout_frame = frames_queue_ready_.front();
         frames_queue_ready_.pop_front();
-        new_frame_available = true;
-      } else if (pending_paint_ && frames_queue_ready_.size() >= 2 &&
-                 !frames_queue_ready_[1]->IsEndOfStream()) {
-        // Painter could be really slow, therefore we had to skip frames if
-        // 1. We had not reached end of stream.
-        // 2. The next frame of current frame is also out-dated.
-        base::TimeDelta next_remaining_time =
-            frames_queue_ready_[1]->GetTimestamp() - host()->GetTime();
-        if (next_remaining_time.InMicroseconds() <= 0) {
-          // Since the current frame is still hold by painter/compositor, and
-          // the next frame is already timed-out, we should skip the next frame
-          // which is the first frame in the queue.
-          timeout_frame = frames_queue_ready_.front();
-          frames_queue_ready_.pop_front();
-          ++frames_dropped;
-        }
+        ++frames_dropped;
       }
-      if (timeout_frame.get()) {
-        frames_queue_done_.push_back(timeout_frame);
-        ScheduleRead_Locked();
-      }
-      if (new_frame_available) {
-        base::AutoUnlock auto_unlock(lock_);
-        OnFrameAvailable();
-      }
+    }
+    if (timeout_frame.get()) {
+      frames_queue_done_.push_back(timeout_frame);
+      ScheduleRead_Locked();
+    }
+    if (new_frame_available) {
+      base::AutoUnlock auto_unlock(lock_);
+      OnFrameAvailable();
     }
   }
 }
 
 void VideoRendererBase::GetCurrentFrame(scoped_refptr<VideoFrame>* frame_out) {
   base::AutoLock auto_lock(lock_);
   DCHECK(!pending_paint_ && !pending_paint_with_last_available_);
 
   if ((!current_frame_.get() || current_frame_->IsEndOfStream()) &&
       (!last_available_frame_.get() ||
@@ skipping 20 matching lines @@
   base::AutoLock auto_lock(lock_);
 
   // Note that we do not claim |pending_paint_| when we return NULL frame, in
   // that case, |current_frame_| could be changed before PutCurrentFrame.
   if (pending_paint_) {
     DCHECK(current_frame_.get() == frame.get());
     DCHECK(!pending_paint_with_last_available_);
     pending_paint_ = false;
   } else if (pending_paint_with_last_available_) {
     DCHECK(last_available_frame_.get() == frame.get());
+    DCHECK(!pending_paint_);
     pending_paint_with_last_available_ = false;
   } else {
     DCHECK(frame.get() == NULL);
   }
 
   // We had cleared the |pending_paint_| flag, there are chances that current
   // frame is timed-out. We will wake up our main thread to advance the current
   // frame when this is true.
   frame_available_.Signal();
   if (state_ == kFlushing) {
-    FlushBuffers();
+    FlushBuffers_Locked();
   } else if (state_ == kError || state_ == kStopped) {
     DoStopOrErrorFlush_Locked();
   }
 }
 
 void VideoRendererBase::ConsumeVideoFrame(scoped_refptr<VideoFrame> frame) {
   if (frame) {
     PipelineStatistics statistics;
     statistics.video_frames_decoded = 1;
     statistics_callback_->Run(statistics);
   }
 
   base::AutoLock auto_lock(lock_);
 
   if (!frame) {
     EnterErrorState_Locked(PIPELINE_ERROR_DECODE);
     return;
   }
 
   // Decoder could reach seek state before our Seek() get called.
   // We will enter kSeeking
-  if (kFlushed == state_)
+  if (state_ == kFlushed)
     state_ = kSeeking;
 
   // Synchronous flush between filters should prevent this from happening.
   DCHECK_NE(state_, kStopped);
   if (frame.get() && !frame->IsEndOfStream())
     --pending_reads_;
 
   DCHECK(state_ != kUninitialized && state_ != kStopped && state_ != kError);
 
   if (state_ == kPaused || state_ == kFlushing) {
     // Decoder are flushing rubbish video frame, we will not display them.
     if (frame.get() && !frame->IsEndOfStream())
       frames_queue_done_.push_back(frame);
     DCHECK_LE(frames_queue_done_.size(),
               static_cast<size_t>(Limits::kMaxVideoFrames));
 
     // Excluding kPause here, because in pause state, we will never
     // transfer out-bounding buffer. We do not flush buffer when Compositor
     // hold reference to our video frame either.
     if (state_ == kFlushing && pending_paint_ == false)
-      FlushBuffers();
+      FlushBuffers_Locked();
 
     return;
   }
 
   // Discard frames until we reach our desired seek timestamp.
   if (state_ == kSeeking && !frame->IsEndOfStream() &&
       (frame->GetTimestamp() + frame->GetDuration()) <= seek_timestamp_) {
     frames_queue_done_.push_back(frame);
     ScheduleRead_Locked();
   } else {
@@ skipping 24 matching lines @@
       new_frame_available = true;
 
       // If we reach prerolled state before Seek() is called by pipeline,
       // |seek_callback_| is not set, we will return immediately during
       // when Seek() is eventually called.
       if (!seek_cb_.is_null()) {
         ResetAndRunCB(&seek_cb_, PIPELINE_OK);
       }
     }
   } else if (state_ == kFlushing && pending_reads_ == 0 && !pending_paint_) {
-    OnFlushDone();
+    OnFlushDone_Locked();
   }
 
   if (new_frame_available) {
     base::AutoUnlock auto_unlock(lock_);
     OnFrameAvailable();
   }
 }
 
 void VideoRendererBase::ReadInput(scoped_refptr<VideoFrame> frame) {
   // We should never return empty frames or EOS frame.
   DCHECK(frame.get() && !frame->IsEndOfStream());
 
   decoder_->ProduceVideoFrame(frame);
   ++pending_reads_;
 }
 
 void VideoRendererBase::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   DCHECK_NE(kEnded, state_);
   // TODO(jiesun): We use dummy buffer to feed decoder to let decoder to
   // provide buffer pools. In the future, we may want to implement real
   // buffer pool to recycle buffers.
   while (!frames_queue_done_.empty()) {
     scoped_refptr<VideoFrame> video_frame = frames_queue_done_.front();
     frames_queue_done_.pop_front();
     ReadInput(video_frame);
   }
 }
 
-void VideoRendererBase::FlushBuffers() {
+void VideoRendererBase::FlushBuffers_Locked() {
+  lock_.AssertAcquired();
   DCHECK(!pending_paint_);
 
   // We should never put EOF frame into "done queue".
   while (!frames_queue_ready_.empty()) {
     scoped_refptr<VideoFrame> video_frame = frames_queue_ready_.front();
     if (!video_frame->IsEndOfStream()) {
       frames_queue_done_.push_back(video_frame);
     }
     frames_queue_ready_.pop_front();
   }
   if (current_frame_.get() && !current_frame_->IsEndOfStream()) {
     frames_queue_done_.push_back(current_frame_);
   }
   current_frame_ = NULL;
 
   // Flush all buffers out to decoder.
   ScheduleRead_Locked();
 
   if (pending_reads_ == 0 && state_ == kFlushing)
-    OnFlushDone();
+    OnFlushDone_Locked();
 }
 
-void VideoRendererBase::OnFlushDone() {
-  // Check all buffers are return to owners.
+void VideoRendererBase::OnFlushDone_Locked() {
+  lock_.AssertAcquired();
+  // Check all buffers are returned to owners.
   DCHECK_EQ(frames_queue_done_.size(), 0u);
   DCHECK(!current_frame_.get());
   DCHECK(frames_queue_ready_.empty());
 
   if (flush_callback_.get()) {  // This ensures callback is invoked once.
     flush_callback_->Run();
     flush_callback_.reset();
   }
   state_ = kFlushed;
 }
@@ skipping 70 matching lines @@
   host()->SetError(status);
 
   if (callback.get())
     callback->Run();
 }
 
 void VideoRendererBase::DoStopOrErrorFlush_Locked() {
   DCHECK(!pending_paint_);
   DCHECK(!pending_paint_with_last_available_);
   lock_.AssertAcquired();
-  FlushBuffers();
+  FlushBuffers_Locked();
   last_available_frame_ = NULL;
   DCHECK_EQ(pending_reads_, 0);
 }
 
 }  // namespace media