Freeze media time and audio rendering when the system suspends.

media/renderers/audio_renderer_impl_unittest.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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 730 matching lines @@
   EXPECT_EQ(frames_read, bus->frames());
   const int zero_frames =
       bus->frames() * (kBuffers - static_cast<int>(kBuffers));
 
   for (int i = 0; i < zero_frames; ++i)
     ASSERT_FLOAT_EQ(0.0f, bus->channel(0)[i]);
   for (int i = zero_frames; i < bus->frames(); ++i)
     ASSERT_NE(0.0f, bus->channel(0)[i]);
 }
 
+TEST_F(AudioRendererImplTest, RenderingDelayedForSuspend) {
+  Initialize();
+  Preroll(base::TimeDelta(), base::TimeDelta(), PIPELINE_OK);
+  StartTicking();
+
+  // Verify the first buffer is real data.
+  int frames_read = 0;
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(hardware_params_);
+  EXPECT_TRUE(sink_->Render(bus.get(), 0, &frames_read));
+  EXPECT_NE(0, frames_read);
+  for (int i = 0; i < bus->frames(); ++i)
+    ASSERT_NE(0.0f, bus->channel(0)[i]);
+
+  // Verify after suspend we get silence.
+  renderer_->OnSuspend();

[xhwang, 2016/06/17 07:12:52]

Can you actually use TestPowerMonitorSource so we are closer to the real use
case? e.g.

https://cs.chromium.org/chromium/src/net/url_request/url_request_unittest.cc?...

+  EXPECT_TRUE(sink_->Render(bus.get(), 0, &frames_read));
+  EXPECT_EQ(0, frames_read);
+
+  // Verify after resume we get audio.
+  bus->Zero();
+  renderer_->OnResume();
+  EXPECT_TRUE(sink_->Render(bus.get(), 0, &frames_read));
+  EXPECT_NE(0, frames_read);
+  for (int i = 0; i < bus->frames(); ++i)
+    ASSERT_NE(0.0f, bus->channel(0)[i]);
+}
+
 TEST_F(AudioRendererImplTest, RenderingDelayDoesNotOverflow) {
   Initialize();
 
   // Choose a first timestamp as far into the future as possible. Without care
   // this can cause an overflow in rendering arithmetic.
   Preroll(base::TimeDelta(), base::TimeDelta::Max(), PIPELINE_OK);
   StartTicking();
   EXPECT_TRUE(ConsumeBufferedData(OutputFrames(1)));
 }
 
@@ skipping 91 matching lines @@
   OutputFrames frames_to_consume(frames_buffered().value / 2);
   EXPECT_TRUE(ConsumeBufferedData(frames_to_consume));
   WaitForPendingRead();
 
   // Time shouldn't change just yet because we've only sent the initial audio
   // data to the hardware.
   EXPECT_EQ(tick_clock_->NowTicks(),
             ConvertMediaTime(base::TimeDelta(), &is_time_moving));
   EXPECT_TRUE(is_time_moving);
 
+  // A system suspend should freeze the time state and resume restart it.
+  renderer_->OnSuspend();
+  EXPECT_EQ(tick_clock_->NowTicks(),
+            ConvertMediaTime(base::TimeDelta(), &is_time_moving));
+  EXPECT_FALSE(is_time_moving);
+  renderer_->OnResume();
+  EXPECT_EQ(tick_clock_->NowTicks(),
+            ConvertMediaTime(base::TimeDelta(), &is_time_moving));
+  EXPECT_TRUE(is_time_moving);
+
   // Consume some more audio data.
   frames_to_consume = frames_buffered();
   tick_clock_->Advance(
       base::TimeDelta::FromSecondsD(1.0 / kOutputSamplesPerSecond));
   EXPECT_TRUE(ConsumeBufferedData(frames_to_consume));
 
   // Time should change now that the audio hardware has called back.
   const base::TimeTicks wall_clock_time_zero =
       tick_clock_->NowTicks() -
       timestamp_helper.GetFrameDuration(frames_to_consume.value);
@@ skipping 70 matching lines @@
   // Advance far enough that we shouldn't be clamped to current time (tested
   // already above).
   tick_clock_->Advance(kOneSecond);
   EXPECT_EQ(
       current_time + timestamp_helper.GetFrameDuration(frames_to_consume.value),
       CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
 }
 
 }  // namespace media