Merge M52: "Freeze media time and audio rendering when the system suspends."

media/renderers/audio_renderer_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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/power_monitor/power_monitor.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"
 #include "build/build_config.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_buffer_converter.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
@@ skipping 23 matching lines @@
       last_audio_memory_usage_(0),
       last_decoded_sample_rate_(0),
       playback_rate_(0.0),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
+      is_suspending_(false),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
+
+  // Tests may not have a power monitor.
+  base::PowerMonitor* monitor = base::PowerMonitor::Get();
+  if (!monitor)
+    return;
+
+  // PowerObserver's must be added and removed from the same thread, but we
+  // won't remove the observer until we're destructed on |task_runner_| so we
+  // must post it here if we're on the wrong thread.
+  if (task_runner_->BelongsToCurrentThread()) {
+    monitor->AddObserver(this);
+  } else {
+    // Safe to post this without a WeakPtr because this class must be destructed
+    // on the same thread and construction has not completed yet.
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&base::PowerMonitor::AddObserver,
+                                      base::Unretained(monitor), this));
+  }
+  // Do not add anything below this line since the above actions are only safe
+  // as the last lines of the constructor.
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
+  if (base::PowerMonitor::Get())
+    base::PowerMonitor::Get()->RemoveObserver(this);
 
   // If Render() is in progress, this call will wait for Render() to finish.
   // After this call, the |sink_| will not call back into |this| anymore.
   sink_->Stop();
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
 }
 
 void AudioRendererImpl::StartTicking() {
@@ skipping 104 matching lines @@
 bool AudioRendererImpl::GetWallClockTimes(
     const std::vector<base::TimeDelta>& media_timestamps,
     std::vector<base::TimeTicks>* wall_clock_times) {
   base::AutoLock auto_lock(lock_);
   DCHECK(wall_clock_times->empty());
 
   // When playback is paused (rate is zero), assume a rate of 1.0.
   const double playback_rate = playback_rate_ ? playback_rate_ : 1.0;
   const bool is_time_moving = sink_playing_ && playback_rate_ &&
                               !last_render_time_.is_null() &&
-                              stop_rendering_time_.is_null();
+                              stop_rendering_time_.is_null() && !is_suspending_;
 
   // Pre-compute the time until playback of the audio buffer extents, since
   // these values are frequently used below.
   const base::TimeDelta time_until_front =
       audio_clock_->TimeUntilPlayback(audio_clock_->front_timestamp());
   const base::TimeDelta time_until_back =
       audio_clock_->TimeUntilPlayback(audio_clock_->back_timestamp());
 
   if (media_timestamps.empty()) {
     // Return the current media time as a wall clock time while accounting for
@@ skipping 290 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnWaitingForDecryptionKey();
 }
 
 void AudioRendererImpl::SetVolume(float volume) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(sink_.get());
   sink_->SetVolume(volume);
 }
 
+void AudioRendererImpl::OnSuspend() {
+  base::AutoLock auto_lock(lock_);
+  is_suspending_ = true;
+}
+
+void AudioRendererImpl::OnResume() {
+  base::AutoLock auto_lock(lock_);
+  is_suspending_ = false;
+}
+
 void AudioRendererImpl::DecodedAudioReady(
     AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
   DVLOG(2) << __FUNCTION__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized);
 
   CHECK(pending_read_);
@@ skipping 230 matching lines @@
       stop_rendering_time_ = base::TimeTicks();
     }
 
     // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
     if (!algorithm_) {
       audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
                                playback_rate_);
       return 0;
     }
 
-    if (playback_rate_ == 0) {
+    if (playback_rate_ == 0 || is_suspending_) {
       audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
                                playback_rate_);
       return 0;
     }
 
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
       audio_clock_->WroteAudio(0, frames_requested, frames_delayed,
                                playback_rate_);
       return 0;
@@ skipping 160 matching lines @@
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media