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 76 matching lines @@
       playback_rate_(0.0),
       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
       video_buffering_state_(BUFFERING_HAVE_NOTHING),
       audio_ended_(false),
       video_ended_(false),
       cdm_context_(nullptr),
       underflow_disabled_for_testing_(false),
       clockless_video_playback_enabled_for_testing_(false),
       video_underflow_threshold_(
           base::TimeDelta::FromMilliseconds(kDefaultVideoUnderflowThresholdMs)),
+      restarting_audio_time_(kNoTimestamp),

[DaleCurtis, 2017/05/23 23:35:53]

Can inline initialize this too?

[servolk, 2017/05/23 23:45:22]

Done.

       weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
   DVLOG(1) << __func__;
 
   // TODO(dalecurtis): Remove once experiments for http://crbug.com/470940 are
   // complete.
   int threshold_ms = 0;
   std::string threshold_ms_str(
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kVideoUnderflowThresholdMs));
@@ skipping 150 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_;
+  }
   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