Crash fix: Remove MessageLoop from AudioPowerMonitor and instead use MessageLoopProxy in AudioOutpu…

media/audio/audio_power_monitor_unittest.cc

 // Copyright 2013 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_power_monitor.h"
 
 #include <limits>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "media/base/audio_bus.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 static const int kSampleRate = 48000;
 static const int kFramesPerBuffer = 128;
 
 static const int kTimeConstantMillis = 5;
-static const int kMeasurementPeriodMillis = 20;
 
 namespace {
 
 // Container for each parameterized test's data (input and expected results).
 class TestScenario {
  public:
   TestScenario(const float* data, int num_channels, int num_frames,
                float expected_power, bool expected_clipped)
       : expected_power_(expected_power), expected_clipped_(expected_clipped) {
     CreatePopulatedBuffer(data, num_channels, num_frames);
@@ skipping 118 matching lines @@
   bool last_clipped_;
 
   DISALLOW_COPY_AND_ASSIGN(MeasurementObserver);
 };
 
 }  // namespace
 
 class AudioPowerMonitorTest : public ::testing::TestWithParam<TestScenario> {
  public:
   AudioPowerMonitorTest()
-      : power_monitor_(
-            kSampleRate,
-            base::TimeDelta::FromMilliseconds(kTimeConstantMillis),
-            base::TimeDelta::FromMilliseconds(kMeasurementPeriodMillis),
-            &message_loop_,
-            base::Bind(&AudioPowerMonitorTest::OnPowerMeasured,
-                       base::Unretained(this))) {}
+      : power_monitor_(kSampleRate,
+                       base::TimeDelta::FromMilliseconds(kTimeConstantMillis)) {
+  }
 
   void FeedAndCheckExpectedPowerIsMeasured(
       const AudioBus& bus, float power, bool clipped) {
-    // Feed the AudioPowerMonitor.  It should post tasks to |message_loop_|.
+    // Feed the AudioPowerMonitor, read measurements from it, and record them in
+    // MeasurementObserver.
     static const int kNumFeedIters = 100;
-    for (int i = 0; i < kNumFeedIters; ++i)
+    MeasurementObserver observer(power, clipped);
+    for (int i = 0; i < kNumFeedIters; ++i) {
       power_monitor_.Scan(bus, bus.frames());
-
-    // Set up an observer and run all the enqueued tasks.
-    MeasurementObserver observer(power, clipped);
-    current_observer_ = &observer;
-    message_loop_.RunUntilIdle();
-    current_observer_ = NULL;
+      const std::pair<float, bool>& reading =
+          power_monitor_.ReadCurrentPowerAndClip();
+      observer.OnPowerMeasured(reading.first, reading.second);
+    }
 
     // Check that the results recorded by the observer are the same whole-number
     // dBFS.
     EXPECT_EQ(static_cast<int>(power),
               static_cast<int>(observer.last_power_measurement()));
     EXPECT_EQ(clipped, observer.last_clipped());
   }
 
  private:
-  void OnPowerMeasured(float power, bool clipped) {
-    CHECK(current_observer_);
-    current_observer_->OnPowerMeasured(power, clipped);
-  }
-
-  base::MessageLoop message_loop_;
   AudioPowerMonitor power_monitor_;
-  MeasurementObserver* current_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioPowerMonitorTest);
 };
 
 TEST_P(AudioPowerMonitorTest, MeasuresPowerOfSignal) {
   const TestScenario& scenario = GetParam();
 
   scoped_ptr<AudioBus> zeroed_bus =
       AudioBus::Create(scenario.data().channels(), scenario.data().frames());
   zeroed_bus->Zero();
@@ skipping 88 matching lines @@
          TestScenario(kMonoMaxAmplitude2, 1, 2,
                       AudioPowerMonitor::max_power(), false),
          TestScenario(kMonoHalfMaxAmplitude, 1, 4, -6, false),
          TestScenario(kMonoAmplitudeClipped, 1, 2,
                       AudioPowerMonitor::max_power(), true),
          TestScenario(kMonoMaxAmplitudeWithClip, 1, 4,
                       AudioPowerMonitor::max_power(), true),
          TestScenario(kMonoMaxAmplitudeWithClip2, 1, 4,
                       AudioPowerMonitor::max_power(), true),
          TestScenario(kMonoSilentNoise, 1, 2,
-                      AudioPowerMonitor::zero_power(), true).
+                      AudioPowerMonitor::zero_power(), false).
              WithABadSample(std::numeric_limits<float>::infinity()),
          TestScenario(kMonoHalfMaxAmplitude, 1, 4,
                       AudioPowerMonitor::zero_power(), false).
              WithABadSample(std::numeric_limits<float>::quiet_NaN()),
          TestScenario(kStereoSilentNoise, 2, 2, -46, false),
          TestScenario(kStereoMaxAmplitude, 2, 2,
                       AudioPowerMonitor::max_power(), false),
          TestScenario(kRightChannelMaxAmplitude, 2, 4, -3, false),
          TestScenario(kLeftChannelHalfMaxAmplitude, 2, 4, -9, false),
          TestScenario(kStereoMixed, 2, 4, -2, false),
          TestScenario(kStereoMixed2, 2, 8, -3, false)));
 
 }  // namespace media