Revert of Gardening: Revert "Use AudioStreamMonitor to control power save blocking."

media/audio/audio_output_controller.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/audio/audio_output_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "base/task_runner_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/scoped_histogram_timer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
-#if defined(AUDIO_POWER_MONITORING)
-// Time constant for AudioPowerMonitor.  See AudioPowerMonitor ctor comments for
-// semantics.  This value was arbitrarily chosen, but seems to work well.
-static const int kPowerMeasurementTimeConstantMillis = 10;
-#endif
-
 AudioOutputController::AudioOutputController(
     AudioManager* audio_manager,
     EventHandler* handler,
     const AudioParameters& params,
     const std::string& output_device_id,
     SyncReader* sync_reader)
     : audio_manager_(audio_manager),
       params_(params),
       handler_(handler),
       output_device_id_(output_device_id),
       stream_(NULL),
       diverting_to_stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
       sync_reader_(sync_reader),
       message_loop_(audio_manager->GetTaskRunner()),
-#if defined(AUDIO_POWER_MONITORING)
       power_monitor_(
           params.sample_rate(),
           TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMillis)),
-#endif
       on_more_io_data_called_(0) {
   DCHECK(audio_manager);
   DCHECK(handler_);
   DCHECK(sync_reader_);
   DCHECK(message_loop_.get());
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
 }
@@ skipping 136 matching lines @@
   handler_->OnPlaying();
 }
 
 void AudioOutputController::StopStream() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kPlaying) {
     wedge_timer_.reset();
     stream_->Stop();
 
-#if defined(AUDIO_POWER_MONITORING)
     // A stopped stream is silent, and power_montior_.Scan() is no longer being
     // called; so we must reset the power monitor.
     power_monitor_.Reset();
-#endif
 
     state_ = kPaused;
   }
 }
 
 void AudioOutputController::DoPause() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.PauseTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoPause");
 
@@ skipping 81 matching lines @@
   // thread starts, its safe to compare and then increment.
   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
     base::AtomicRefCountInc(&on_more_io_data_called_);
 
   sync_reader_->Read(dest);
 
   const int frames = dest->frames();
   sync_reader_->UpdatePendingBytes(
       buffers_state.total_bytes() + frames * params_.GetBytesPerFrame());
 
-#if defined(AUDIO_POWER_MONITORING)
-  power_monitor_.Scan(*dest, frames);
-#endif
+  if (will_monitor_audio_levels())
+    power_monitor_.Scan(*dest, frames);
 
   return frames;
 }
 
 void AudioOutputController::OnError(AudioOutputStream* stream) {
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoReportError, this));
 }
 
@@ skipping 83 matching lines @@
     return;
 
   // Note: OnDeviceChange() will cause the existing stream (the consumer of the
   // diverted audio data) to be closed, and diverting_to_stream_ will be set
   // back to NULL.
   OnDeviceChange();
   DCHECK(!diverting_to_stream_);
 }
 
 std::pair<float, bool> AudioOutputController::ReadCurrentPowerAndClip() {
-#if defined(AUDIO_POWER_MONITORING)
+  DCHECK(will_monitor_audio_levels());
   return power_monitor_.ReadCurrentPowerAndClip();
-#else
-  NOTREACHED();
-  return std::make_pair(AudioPowerMonitor::zero_power(), false);
-#endif
 }
 
 void AudioOutputController::WedgeCheck() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media