Fix deferred video underflow if audio underflows first.

media/renderers/renderer_impl.cc

 // Copyright 2014 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/renderers/renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 387 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ == STATE_ERROR) {
     DCHECK(flush_cb_.is_null());
     return;
   }
 
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
 
+  // If we had a deferred video renderer underflow prior to the flush, it should
+  // have been cleared by the audio renderer changing to BUFFERING_HAVE_NOTHING.
+  DCHECK(deferred_underflow_cb_.IsCancelled());
+
   DCHECK_EQ(audio_buffering_state_, BUFFERING_HAVE_NOTHING);
   audio_ended_ = false;
   FlushVideoRenderer();
 }
 
 void RendererImpl::FlushVideoRenderer() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING);
   DCHECK(!flush_cb_.is_null());
@@ skipping 32 matching lines @@
 
 void RendererImpl::OnBufferingStateChanged(BufferingState* buffering_state,
                                            BufferingState new_buffering_state) {
   const bool is_audio = buffering_state == &audio_buffering_state_;
   DVLOG(1) << __FUNCTION__ << "(" << *buffering_state << ", "
            << new_buffering_state << ") " << (is_audio ? "audio" : "video");
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   bool was_waiting_for_enough_data = WaitingForEnoughData();
 
-  // When audio is present, defer underflow callbacks for some time to avoid
-  // unnecessary glitches in audio; see http://crbug.com/144683#c53.
+  // When audio is present and has enough data, defer video underflow callbacks
+  // for some time to avoid unnecessary glitches in audio; see
+  // http://crbug.com/144683#c53.
   if (audio_renderer_ && !is_audio && state_ == STATE_PLAYING) {
     if (video_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
+        audio_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
         new_buffering_state == BUFFERING_HAVE_NOTHING &&
         deferred_underflow_cb_.IsCancelled()) {
       deferred_underflow_cb_.Reset(base::Bind(
           &RendererImpl::OnBufferingStateChanged, weak_factory_.GetWeakPtr(),
           buffering_state, new_buffering_state));
       task_runner_->PostDelayedTask(FROM_HERE,
                                     deferred_underflow_cb_.callback(),
                                     video_underflow_threshold_);
       return;
     }
@@ skipping 157 matching lines @@
   }
 
   // After OnError() returns, the pipeline may destroy |this|.
   base::ResetAndReturn(&error_cb_).Run(error);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 }
 
 }  // namespace media