CL for perf tryjob on linux

media/base/pipeline_impl.cc

 // Copyright (c) 2012 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/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/base/serial_runner.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 
+namespace {
 static const double kDefaultPlaybackRate = 0.0;
 static const float kDefaultVolume = 1.0f;
 
+base::TimeDelta CurrentMediaTime(base::TimeDelta min_time,
+                                 base::TimeDelta max_time,
+                                 base::TimeTicks ref_time,
+                                 base::TimeTicks curr_time,
+                                 double playback_rate) {
+  DCHECK(!ref_time.is_null());
+  return std::min(min_time + (curr_time - ref_time) * playback_rate, max_time);
+}
+
+}  // namespace
+
 namespace media {
 
 class PipelineImpl::RendererWrapper : public DemuxerHost,
                                       public RendererClient {
  public:
   RendererWrapper(scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
                   scoped_refptr<MediaLog> media_log);
   ~RendererWrapper() final;
 
   void Start(Demuxer* demuxer,
              std::unique_ptr<Renderer> renderer,
              std::unique_ptr<TextRenderer> text_renderer,
              base::WeakPtr<PipelineImpl> weak_pipeline);
   void Stop(const base::Closure& stop_cb);
   void Seek(base::TimeDelta time);
   void Suspend();
   void Resume(std::unique_ptr<Renderer> renderer, base::TimeDelta time);
   void SetPlaybackRate(double playback_rate);
   void SetVolume(float volume);
-  base::TimeDelta GetMediaTime() const;
+  void GetMediaTimeExtents(base::TimeDelta* time_min,
+                           base::TimeDelta* time_max,
+                           base::TimeTicks* time_reference) const;
   Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
   bool DidLoadingProgress();
   PipelineStatistics GetStatistics() const;
   void SetCdm(CdmContext* cdm_context, const CdmAttachedCB& cdm_attached_cb);
 
   // |enabledTrackIds| contains track ids of enabled audio tracks.
   void OnEnabledAudioTracksChanged(
       const std::vector<MediaTrack::Id>& enabledTrackIds);
 
   // |trackId| either empty, which means no video track is selected, or contain
   // one element - the selected video track id.
   void OnSelectedVideoTrackChanged(
       const std::vector<MediaTrack::Id>& selectedTrackId);
 
  private:
   // Contains state shared between main and media thread.
   // Main thread can only read. Media thread can both - read and write.
   // So it is not necessary to lock when reading from the media thread.
   // This struct should only contain state that is not immediately needed by
   // PipelineClient and can be cached on the media thread until queried.
   // Alternatively we could cache it on the main thread by posting the
   // notification to the main thread. But some of the state change notifications
   // (OnStatisticsUpdate and OnBufferedTimeRangesChanged) arrive much more
   // frequently than needed. Posting all those notifications to the main thread
   // causes performance issues: crbug.com/619975.
   struct SharedState {
-    // TODO(scherkus): Enforce that Renderer is only called on a single thread,
-    // even for accessing media time http://crbug.com/370634
-    std::unique_ptr<Renderer> renderer;
-
     // True when OnBufferedTimeRangesChanged() has been called more recently
     // than DidLoadingProgress().
     bool did_loading_progress = false;
 
     // Amount of available buffered data as reported by Demuxer.
     Ranges<base::TimeDelta> buffered_time_ranges;
 
     // Accumulated statistics reported by the renderer.
     PipelineStatistics statistics;
 
-    // The media timestamp to return while the pipeline is suspended.
-    // Otherwise set to kNoTimestamp.
-    base::TimeDelta suspend_timestamp = kNoTimestamp;
+    // Media time extents reported by the renderer.
+    base::TimeDelta media_time_min;
+    base::TimeDelta media_time_max;
+    base::TimeTicks media_time_reference;
   };
 
   // DemuxerHost implementaion.
   void OnBufferedTimeRangesChanged(const Ranges<base::TimeDelta>& ranges) final;
   void SetDuration(base::TimeDelta duration) final;
   void OnDemuxerError(PipelineStatus error) final;
   void AddTextStream(DemuxerStream* text_stream,
                      const TextTrackConfig& config) final;
   void RemoveTextStream(DemuxerStream* text_stream) final;
 
   // RendererClient implementation.
   void OnError(PipelineStatus error) final;
   void OnEnded() final;
   void OnStatisticsUpdate(const PipelineStatistics& stats) final;
   void OnBufferingStateChange(BufferingState state) final;
   void OnWaitingForDecryptionKey() final;
   void OnVideoNaturalSizeChange(const gfx::Size& size) final;
   void OnVideoOpacityChange(bool opaque) final;
+  void OnTimeUpdate(base::TimeDelta curr_time,
+                    base::TimeDelta max_time,
+                    base::TimeTicks capture_time) final;
 
   // TextRenderer tasks and notifications.
   void OnTextRendererEnded();
   void AddTextStreamTask(DemuxerStream* text_stream,
                          const TextTrackConfig& config);
   void RemoveTextStreamTask(DemuxerStream* text_stream);
 
   // Common handlers for notifications from renderers and demuxer.
   void OnPipelineError(PipelineStatus error);
   void OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
                      CdmContext* cdm_context,
                      bool success);
   void CheckPlaybackEnded();
 
   // State transition tasks.
   void SetState(State next_state);
   void CompleteSeek(base::TimeDelta seek_time, PipelineStatus status);
   void CompleteSuspend(PipelineStatus status);
   void InitializeDemuxer(const PipelineStatusCB& done_cb);
   void InitializeRenderer(const PipelineStatusCB& done_cb);
-  void DestroyRenderer();
   void ReportMetadata();
 
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const scoped_refptr<MediaLog> media_log_;
 
   base::WeakPtr<PipelineImpl> weak_pipeline_;
   Demuxer* demuxer_;
+  std::unique_ptr<Renderer> renderer_;
   std::unique_ptr<TextRenderer> text_renderer_;
   double playback_rate_;
   float volume_;
   CdmContext* cdm_context_;
 
   // Lock used to serialize |shared_state_|.
   mutable base::Lock shared_state_lock_;
 
   // State shared between main and media thread.
   SharedState shared_state_;
@@ skipping 54 matching lines @@
     std::unique_ptr<Renderer> renderer,
     std::unique_ptr<TextRenderer> text_renderer,
     base::WeakPtr<PipelineImpl> weak_pipeline) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(kCreated, state_) << "Received start in unexpected state: "
                               << state_;
 
   SetState(kStarting);
 
   DCHECK(!demuxer_);
-  DCHECK(!shared_state_.renderer);
+  DCHECK(!renderer_);
   DCHECK(!text_renderer_);
   DCHECK(!renderer_ended_);
   DCHECK(!text_renderer_ended_);
   DCHECK(!weak_pipeline_);
   demuxer_ = demuxer;
-  {
-    base::AutoLock auto_lock(shared_state_lock_);
-    shared_state_.renderer = std::move(renderer);
-  }
+  renderer_ = std::move(renderer);
   text_renderer_ = std::move(text_renderer);
   if (text_renderer_) {
     text_renderer_->Initialize(
         base::Bind(&RendererWrapper::OnTextRendererEnded, weak_this_));
   }
   weak_pipeline_ = weak_pipeline;
 
   // Queue asynchronous actions required to start.
   DCHECK(!pending_callbacks_);
   SerialRunner::Queue fns;
@@ skipping 24 matching lines @@
     UMA_HISTOGRAM_COUNTS("Media.DroppedFrameCount",
                          shared_state_.statistics.video_frames_dropped);
   }
 
   // If we stop during starting/seeking/suspending/resuming we don't want to
   // leave outstanding callbacks around. The callbacks also do not get run if
   // the pipeline is stopped before it had a chance to complete outstanding
   // tasks.
   pending_callbacks_.reset();
 
-  DestroyRenderer();
+  renderer_.reset();
   text_renderer_.reset();
-
   if (demuxer_) {
     demuxer_->Stop();
     demuxer_ = NULL;
   }
 
   SetState(kStopped);
 
   // Post the stop callback to enqueue it after the tasks that may have been
   // posted by Demuxer and Renderer during stopping. Note that in theory the
   // tasks posted by Demuxer/Renderer may post even more tasks that will get
   // enqueued after |stop_cb|. This may be problematic because Demuxer may
   // get destroyed as soon as |stop_cb| is run. In practice this is not a
   // problem, but ideally Demuxer should be destroyed on the media thread.
   media_task_runner_->PostTask(FROM_HERE, stop_cb);
 }
 
 void PipelineImpl::RendererWrapper::Seek(base::TimeDelta time) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Suppress seeking if we're not fully started.
   if (state_ != kPlaying) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive seek in unexpected state: " << state_;
     OnPipelineError(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
 
-  base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
-
   SetState(kSeeking);
   renderer_ended_ = false;
   text_renderer_ended_ = false;
 
   // Queue asynchronous actions required to start.
   DCHECK(!pending_callbacks_);
   SerialRunner::Queue bound_fns;
 
   // Pause.
   if (text_renderer_) {
     bound_fns.Push(base::Bind(&TextRenderer::Pause,
                               base::Unretained(text_renderer_.get())));
   }
 
   // Flush.
-  DCHECK(shared_state_.renderer);
-  bound_fns.Push(base::Bind(&Renderer::Flush,
-                            base::Unretained(shared_state_.renderer.get())));
+  DCHECK(renderer_);
+  bound_fns.Push(
+      base::Bind(&Renderer::Flush, base::Unretained(renderer_.get())));
 
   if (text_renderer_) {
     bound_fns.Push(base::Bind(&TextRenderer::Flush,
                               base::Unretained(text_renderer_.get())));
   }
 
   // Seek demuxer.
+  base::TimeDelta seek_time = std::max(time, demuxer_->GetStartTime());
   bound_fns.Push(
-      base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
+      base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), seek_time));
 
   // Run tasks.
   pending_callbacks_ = SerialRunner::Run(
       bound_fns,
-      base::Bind(&RendererWrapper::CompleteSeek, weak_this_, seek_timestamp));
+      base::Bind(&RendererWrapper::CompleteSeek, weak_this_, seek_time));
 }
 
 void PipelineImpl::RendererWrapper::Suspend() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Suppress suspending if we're not playing.
   if (state_ != kPlaying) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive suspend in unexpected state: " << state_;
     OnPipelineError(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
-  DCHECK(shared_state_.renderer);
+  DCHECK(renderer_);
   DCHECK(!pending_callbacks_.get());
 
   SetState(kSuspending);
 
   // Freeze playback and record the media time before flushing. (Flushing clears
   // the value.)
-  shared_state_.renderer->SetPlaybackRate(0.0);
+  renderer_->SetPlaybackRate(0.0);
+  base::TimeDelta media_time = renderer_->GetMediaTime();
   {
     base::AutoLock auto_lock(shared_state_lock_);
-    shared_state_.suspend_timestamp = shared_state_.renderer->GetMediaTime();
-    DCHECK(shared_state_.suspend_timestamp != kNoTimestamp);
+    shared_state_.media_time_min = media_time;
+    shared_state_.media_time_max = media_time;
+    shared_state_.media_time_reference = base::TimeTicks();
   }
 
   // Queue the asynchronous actions required to stop playback.
   SerialRunner::Queue fns;
 
   if (text_renderer_) {
     fns.Push(base::Bind(&TextRenderer::Pause,
                         base::Unretained(text_renderer_.get())));
   }
 
-  fns.Push(base::Bind(&Renderer::Flush,
-                      base::Unretained(shared_state_.renderer.get())));
+  fns.Push(base::Bind(&Renderer::Flush, base::Unretained(renderer_.get())));
 
   if (text_renderer_) {
     fns.Push(base::Bind(&TextRenderer::Flush,
                         base::Unretained(text_renderer_.get())));
   }
 
   pending_callbacks_ = SerialRunner::Run(
       fns, base::Bind(&RendererWrapper::CompleteSuspend, weak_this_));
 }
 
 void PipelineImpl::RendererWrapper::Resume(std::unique_ptr<Renderer> renderer,
                                            base::TimeDelta timestamp) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Suppress resuming if we're not suspended.
   if (state_ != kSuspended) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive resume in unexpected state: " << state_;
     OnPipelineError(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
-  DCHECK(!shared_state_.renderer);
+  DCHECK(!renderer_);
   DCHECK(!pending_callbacks_.get());
 
   SetState(kResuming);
 
-  {
-    base::AutoLock auto_lock(shared_state_lock_);
-    shared_state_.renderer = std::move(renderer);
-  }
-
+  renderer_ = std::move(renderer);
   renderer_ended_ = false;
   text_renderer_ended_ = false;
   base::TimeDelta start_timestamp =
       std::max(timestamp, demuxer_->GetStartTime());
 
   // Queue the asynchronous actions required to start playback.
   SerialRunner::Queue fns;
 
   fns.Push(
       base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), start_timestamp));
 
   fns.Push(base::Bind(&RendererWrapper::InitializeRenderer, weak_this_));
 
   pending_callbacks_ = SerialRunner::Run(
       fns,
       base::Bind(&RendererWrapper::CompleteSeek, weak_this_, start_timestamp));
 }
 
 void PipelineImpl::RendererWrapper::SetPlaybackRate(double playback_rate) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
+  if (!shared_state_.media_time_reference.is_null()) {
+    base::AutoLock auto_lock(shared_state_lock_);
+    base::TimeTicks now_time = base::TimeTicks::Now();
+    shared_state_.media_time_min = CurrentMediaTime(
+        shared_state_.media_time_min, shared_state_.media_time_max,
+        shared_state_.media_time_reference, now_time, playback_rate_);
+    shared_state_.media_time_reference = now_time;
+  }
+
   playback_rate_ = playback_rate;
   if (state_ == kPlaying)
-    shared_state_.renderer->SetPlaybackRate(playback_rate_);
+    renderer_->SetPlaybackRate(playback_rate_);
 }
 
 void PipelineImpl::RendererWrapper::SetVolume(float volume) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   volume_ = volume;
   if (state_ == kPlaying)
-    shared_state_.renderer->SetVolume(volume_);
+    renderer_->SetVolume(volume_);
 }
 
-base::TimeDelta PipelineImpl::RendererWrapper::GetMediaTime() const {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
+void PipelineImpl::RendererWrapper::GetMediaTimeExtents(
+    base::TimeDelta* time_min,
+    base::TimeDelta* time_max,
+    base::TimeTicks* time_reference) const {
+  base::AutoLock auto_lock(shared_state_lock_);
 
-  base::AutoLock auto_lock(shared_state_lock_);
-  if (shared_state_.suspend_timestamp != kNoTimestamp)
-    return shared_state_.suspend_timestamp;
-  return shared_state_.renderer ? shared_state_.renderer->GetMediaTime()
-                                : base::TimeDelta();
+  *time_min = shared_state_.media_time_min;
+  *time_max = shared_state_.media_time_max;
+  *time_reference = shared_state_.media_time_reference;
 }
 
 Ranges<base::TimeDelta> PipelineImpl::RendererWrapper::GetBufferedTimeRanges()
     const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   return shared_state_.buffered_time_ranges;
 }
 
@@ skipping 11 matching lines @@
 
   base::AutoLock auto_lock(shared_state_lock_);
   return shared_state_.statistics;
 }
 
 void PipelineImpl::RendererWrapper::SetCdm(
     CdmContext* cdm_context,
     const CdmAttachedCB& cdm_attached_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
-  if (!shared_state_.renderer) {
+  if (!renderer_) {
     cdm_context_ = cdm_context;
     cdm_attached_cb.Run(true);
     return;
   }
 
-  shared_state_.renderer->SetCdm(
-      cdm_context, base::Bind(&RendererWrapper::OnCdmAttached, weak_this_,
-                              cdm_attached_cb, cdm_context));
+  renderer_->SetCdm(cdm_context,
+                    base::Bind(&RendererWrapper::OnCdmAttached, weak_this_,
+                               cdm_attached_cb, cdm_context));
 }
 
 void PipelineImpl::RendererWrapper::OnBufferedTimeRangesChanged(
     const Ranges<base::TimeDelta>& ranges) {
   // TODO(alokp): Add thread DCHECK after ensuring that all Demuxer
   // implementations call DemuxerHost on the media thread.
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.did_loading_progress = true;
   shared_state_.buffered_time_ranges = ranges;
 }
@@ skipping 79 matching lines @@
     const std::vector<MediaTrack::Id>& enabledTrackIds) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Track status notifications might be delivered asynchronously. If we receive
   // a notification when pipeline is stopped/shut down, it's safe to ignore it.
   if (state_ == kStopping || state_ == kStopped) {
     return;
   }
 
   DCHECK(demuxer_);
-  DCHECK(shared_state_.renderer);
+  DCHECK(renderer_);
 
-  base::TimeDelta currTime = (state_ == kPlaying)
-                                 ? shared_state_.renderer->GetMediaTime()
-                                 : demuxer_->GetStartTime();
+  base::TimeDelta currTime = (state_ == kPlaying) ? renderer_->GetMediaTime()
+                                                  : demuxer_->GetStartTime();
   demuxer_->OnEnabledAudioTracksChanged(enabledTrackIds, currTime);
 }
 
 void PipelineImpl::RendererWrapper::OnSelectedVideoTrackChanged(
     const std::vector<MediaTrack::Id>& selectedTrackId) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Track status notifications might be delivered asynchronously. If we receive
   // a notification when pipeline is stopped/shut down, it's safe to ignore it.
   if (state_ == kStopping || state_ == kStopped) {
     return;
   }
 
   DCHECK(demuxer_);
-  DCHECK(shared_state_.renderer);
+  DCHECK(renderer_);
 
-  base::TimeDelta currTime = (state_ == kPlaying)
-                                 ? shared_state_.renderer->GetMediaTime()
-                                 : demuxer_->GetStartTime();
+  base::TimeDelta currTime = (state_ == kPlaying) ? renderer_->GetMediaTime()
+                                                  : demuxer_->GetStartTime();
   demuxer_->OnSelectedVideoTrackChanged(selectedTrackId, currTime);
 }
 
 void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
     const PipelineStatistics& stats) {
   DVLOG(3) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.statistics.audio_bytes_decoded += stats.audio_bytes_decoded;
@@ skipping 32 matching lines @@
 }
 
 void PipelineImpl::RendererWrapper::OnVideoOpacityChange(bool opaque) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::OnVideoOpacityChange, weak_pipeline_, opaque));
 }
 
+void PipelineImpl::RendererWrapper::OnTimeUpdate(base::TimeDelta curr_time,
+                                                 base::TimeDelta max_time,
+                                                 base::TimeTicks capture_time) {
+  DVLOG(4) << __func__ << "(" << curr_time.InMicroseconds() << ", "
+           << max_time.InMicroseconds() << ", " << capture_time << ")";
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  base::AutoLock auto_lock(shared_state_lock_);
+  shared_state_.media_time_min = curr_time;
+  shared_state_.media_time_max = max_time;
+  shared_state_.media_time_reference = capture_time;
+}
+
 void PipelineImpl::RendererWrapper::OnTextRendererEnded() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::TEXT_ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!text_renderer_ended_);
   text_renderer_ended_ = true;
   CheckPlaybackEnded();
@@ skipping 49 matching lines @@
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   if (success)
     cdm_context_ = cdm_context;
   cdm_attached_cb.Run(success);
 }
 
 void PipelineImpl::RendererWrapper::CheckPlaybackEnded() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
-  if (shared_state_.renderer && !renderer_ended_)
+  if (renderer_ && !renderer_ended_)
     return;
 
   if (text_renderer_ && text_renderer_->HasTracks() && !text_renderer_ended_)
     return;
 
   DCHECK_EQ(status_, PIPELINE_OK);
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PipelineImpl::OnEnded, weak_pipeline_));
 }
 
@@ skipping 12 matching lines @@
   DCHECK(state_ == kStarting || state_ == kSeeking || state_ == kResuming);
 
   DCHECK(pending_callbacks_);
   pending_callbacks_.reset();
 
   if (status != PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
-  shared_state_.renderer->StartPlayingFrom(
-      std::max(seek_time, demuxer_->GetStartTime()));
-  {
-    base::AutoLock auto_lock(shared_state_lock_);
-    shared_state_.suspend_timestamp = kNoTimestamp;
-  }
+  seek_time = std::max(seek_time, demuxer_->GetStartTime());
+  renderer_->StartPlayingFrom(seek_time);
+  renderer_->SetPlaybackRate(playback_rate_);
+  renderer_->SetVolume(volume_);
 
   if (text_renderer_)
     text_renderer_->StartPlaying();
 
-  shared_state_.renderer->SetPlaybackRate(playback_rate_);
-  shared_state_.renderer->SetVolume(volume_);
+  {
+    base::AutoLock auto_lock(shared_state_lock_);
+    shared_state_.media_time_min = seek_time;
+    shared_state_.media_time_max = seek_time;
+    shared_state_.media_time_reference = base::TimeTicks();
+  }
 
   SetState(kPlaying);
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PipelineImpl::OnSeekDone, weak_pipeline_));
 }
 
 void PipelineImpl::RendererWrapper::CompleteSuspend(PipelineStatus status) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(kSuspending, state_);
 
   DCHECK(pending_callbacks_);
   pending_callbacks_.reset();
 
   // In case we are suspending or suspended, the error may be recoverable,
   // so don't propagate it now, instead let the subsequent seek during resume
   // propagate it if it's unrecoverable.
   LOG_IF(WARNING, status != PIPELINE_OK)
       << "Encountered pipeline error while suspending: " << status;
 
-  DestroyRenderer();
+  renderer_.reset();
   {
     base::AutoLock auto_lock(shared_state_lock_);
     shared_state_.statistics.audio_memory_usage = 0;
     shared_state_.statistics.video_memory_usage = 0;
   }
 
   SetState(kSuspended);
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PipelineImpl::OnSuspendDone, weak_pipeline_));
 }
 
 void PipelineImpl::RendererWrapper::InitializeDemuxer(
     const PipelineStatusCB& done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   demuxer_->Initialize(this, done_cb, !!text_renderer_);
 }
 
 void PipelineImpl::RendererWrapper::InitializeRenderer(
     const PipelineStatusCB& done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
       !demuxer_->GetStream(DemuxerStream::VIDEO)) {
     done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
     return;
   }
 
   if (cdm_context_)
-    shared_state_.renderer->SetCdm(cdm_context_,
-                                   base::Bind(&IgnoreCdmAttached));
+    renderer_->SetCdm(cdm_context_, base::Bind(&IgnoreCdmAttached));
 
-  shared_state_.renderer->Initialize(demuxer_, this, done_cb);
-}
-
-void PipelineImpl::RendererWrapper::DestroyRenderer() {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-
-  // Destroy the renderer outside the lock scope to avoid holding the lock
-  // while renderer is being destroyed (in case Renderer destructor is costly).
-  std::unique_ptr<Renderer> renderer;
-  {
-    base::AutoLock auto_lock(shared_state_lock_);
-    renderer.swap(shared_state_.renderer);
-  }
+  renderer_->Initialize(demuxer_, this, done_cb);
 }
 
 void PipelineImpl::RendererWrapper::ReportMetadata() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   PipelineMetadata metadata;
   metadata.timeline_offset = demuxer_->GetTimelineOffset();
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   if (stream) {
     metadata.has_video = true;
@@ skipping 122 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!seek_cb.is_null());
 
   if (!IsRunning()) {
     DLOG(ERROR) << "Media pipeline isn't running. Ignoring Seek().";
     return;
   }
 
   DCHECK(seek_cb_.is_null());
   seek_cb_ = seek_cb;
+  media_time_last_ = base::TimeDelta();
+
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RendererWrapper::Seek,
                             base::Unretained(renderer_wrapper_.get()), time));
 }
 
 void PipelineImpl::Suspend(const PipelineStatusCB& suspend_cb) {
   DVLOG(2) << __func__;
   DCHECK(!suspend_cb.is_null());
 
   DCHECK(IsRunning());
   DCHECK(suspend_cb_.is_null());
   suspend_cb_ = suspend_cb;
 
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RendererWrapper::Suspend,
                             base::Unretained(renderer_wrapper_.get())));
 }
 
 void PipelineImpl::Resume(std::unique_ptr<Renderer> renderer,
                           base::TimeDelta time,
                           const PipelineStatusCB& seek_cb) {
   DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(renderer);
   DCHECK(!seek_cb.is_null());
 
   DCHECK(IsRunning());
   DCHECK(seek_cb_.is_null());
   seek_cb_ = seek_cb;
+  media_time_last_ = base::TimeDelta();
 
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RendererWrapper::Resume,
                             base::Unretained(renderer_wrapper_.get()),
                             base::Passed(&renderer), time));
 }
 
 bool PipelineImpl::IsRunning() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !!client_;
@@ skipping 32 matching lines @@
 
   volume_ = volume;
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::SetVolume,
                  base::Unretained(renderer_wrapper_.get()), volume_));
 }
 
 base::TimeDelta PipelineImpl::GetMediaTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return renderer_wrapper_->GetMediaTime();
+
+  base::TimeDelta time_min, time_max;
+  base::TimeTicks time_ref;
+  renderer_wrapper_->GetMediaTimeExtents(&time_min, &time_max, &time_ref);
+
+  // Return the current time based on the known extents of media data plus an
+  // estimate based on the last time those values were calculated.
+  base::TimeDelta media_time =
+      time_ref.is_null()
+          ? time_min
+          : CurrentMediaTime(time_min, time_max, time_ref,
+                             base::TimeTicks::Now(), playback_rate_);
+
+  // Clamp current media time to the last reported value, this prevents higher
+  // level clients from seeing time go backwards based on inaccurate or spurious
+  // delay values reported to the AudioClock.
+  //
+  // It is expected that such events are transient and will be recovered as
+  // rendering continues over time.
+  if (media_time < media_time_last_) {
+    DVLOG(2) << __func__ << ": " << media_time_last_
+             << " (clamped), actual: " << media_time;
+    return media_time_last_;
+  }
+
+  DVLOG(2) << __func__ << ": " << media_time;
+  media_time_last_ = media_time;
+  return media_time;
 }
 
 Ranges<base::TimeDelta> PipelineImpl::GetBufferedTimeRanges() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return renderer_wrapper_->GetBufferedTimeRanges();
 }
 
 base::TimeDelta PipelineImpl::GetMediaDuration() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return duration_;
@@ skipping 155 matching lines @@
 void PipelineImpl::OnSuspendDone() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media