Freeze the reported media time while audio is restarted

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 246 matching lines @@
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_)
     audio_renderer_->SetVolume(volume);
 }
 
 base::TimeDelta RendererImpl::GetMediaTime() {
   // No BelongsToCurrentThread() checking because this can be called from other
   // threads.
+  base::AutoLock lock(restarting_audio_lock_);
+  if (restarting_audio_) {
+    DCHECK_NE(kNoTimestamp, restarting_audio_time_);
+    return restarting_audio_time_;
+  }

[xhwang, 2017/05/24 00:23:41]

If time_source_->CurrentMediaTime() calls back into this class we could end up
in a deadlock. I don't think this will happen, but it's better to err on the
safe side.

To fix that, can we put l.267-271 in a {} block?

[servolk, 2017/05/24 00:28:00]

Done.

   return time_source_->CurrentMediaTime();
 }
 
 void RendererImpl::DisableUnderflowForTesting() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   underflow_disabled_for_testing_ = true;
 }
@@ skipping 291 matching lines @@
                        ? &RendererImpl::RestartVideoRenderer
                        : &RendererImpl::ReinitializeVideoRenderer,
                    weak_this_, stream, time);
     if (state_ == STATE_FLUSHED)
       handle_track_status_cb.Run();
     else
       video_renderer_->Flush(handle_track_status_cb);
   } else if (stream->type() == DemuxerStream::AUDIO) {
     DCHECK(audio_renderer_);
     DCHECK(time_source_);
-    restarting_audio_ = true;
+    {
+      base::AutoLock lock(restarting_audio_lock_);
+      restarting_audio_time_ = time;
+      restarting_audio_ = true;
+    }
     base::Closure handle_track_status_cb =
         base::Bind(stream == current_audio_stream_
                        ? &RendererImpl::RestartAudioRenderer
                        : &RendererImpl::ReinitializeAudioRenderer,
                    weak_this_, stream, time);
     if (state_ == STATE_FLUSHED) {
       handle_track_status_cb.Run();
       return;
     }
     // Stop ticking (transition into paused state) in audio renderer before
@@ skipping 173 matching lines @@
     }
   }
   return false;
 }
 
 void RendererImpl::OnStreamRestartCompleted() {
   DVLOG(3) << __func__ << " restarting_audio_=" << restarting_audio_
            << " restarting_video_=" << restarting_video_;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(restarting_audio_ || restarting_video_);
-  restarting_audio_ = false;
+  {
+    base::AutoLock lock(restarting_audio_lock_);
+    restarting_audio_ = false;
+    restarting_audio_time_ = kNoTimestamp;
+  }
   restarting_video_ = false;
   if (!pending_actions_.empty()) {
     base::Closure closure = pending_actions_.front();
     pending_actions_.pop_front();
     closure.Run();
   }
 }
 
 void RendererImpl::OnBufferingStateChange(DemuxerStream::Type type,
                                           BufferingState new_buffering_state) {
@@ skipping 208 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media