Decouple 'give me more data' and 'rendered end of stream' audio callbacks.

content/renderer/media/audio_renderer_impl_unittest.cc

Index: content/renderer/media/audio_renderer_impl_unittest.cc
===================================================================
--- content/renderer/media/audio_renderer_impl_unittest.cc	(revision 122285)
+++ content/renderer/media/audio_renderer_impl_unittest.cc	(working copy)
@@ -4,11 +4,13 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/gtest_prod_util.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
+#include "base/threading/platform_thread.h"
 #include "content/common/child_process.h"
 #include "content/common/child_thread.h"
 #include "content/renderer/media/audio_renderer_impl.h"
@@ -56,7 +58,21 @@
  public:
   explicit TestAudioRendererImpl(media::AudioRendererSink* sink)
       : AudioRendererImpl(sink) {
+    ON_CALL(*this, current_message_loop_proxy())
+        .WillByDefault(Return(
+            ChildProcess::current()->io_message_loop_proxy()));
   }
+
+ protected:
+  FRIEND_TEST_ALL_PREFIXES(AudioRendererImplTest, OnRenderEndOfStream);
+  FRIEND_TEST_ALL_PREFIXES(AudioRendererImplTest, OnRenderEndOfStreamStopped);
+  MOCK_METHOD0(SignalEndOfStream, void());
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(AudioRendererImplTest, OnRenderEndOfStream);
+  FRIEND_TEST_ALL_PREFIXES(AudioRendererImplTest, OnRenderEndOfStreamStopped);
+  MOCK_METHOD0(OnRenderEndOfStreamDelay, int64());
+  MOCK_METHOD0(current_message_loop_proxy, base::MessageLoopProxy*());
 };
 
 class AudioRendererImplTest
@@ -136,6 +152,19 @@
   }
 
  protected:
+  // Posts a DoSetPlayback task to the IO message loop.
+  void RendererSetPlaybackRate(float rate) {
+    ChildProcess::current()->io_message_loop()->PostTask(
+      FROM_HERE, base::Bind(&AudioRendererImplTest::DoSetPlaybackRate,
+                            base::Unretained(this),
+                            rate));
+  }
+
+  // Called in the message loop.
+  void DoSetPlaybackRate(float rate) {
+    renderer_->SetPlaybackRate(rate);
+  }
+
   // Posts a final task to the IO message loop and waits for completion.
   void WaitForIOThreadCompletion() {
     ChildProcess::current()->io_message_loop()->PostTask(
@@ -150,7 +179,7 @@
   RenderThreadImpl* render_thread_;  // owned by mock_process_
   scoped_ptr<MockRenderProcess> mock_process_;
   scoped_refptr<media::MockAudioDecoder> decoder_;
-  scoped_refptr<AudioRendererImpl> renderer_;
+  scoped_refptr<TestAudioRendererImpl> renderer_;
   scoped_ptr<base::WaitableEvent> event_;
 
  private:
@@ -195,3 +224,35 @@
   renderer_->Stop(media::NewExpectedClosure());
   WaitForIOThreadCompletion();
 }
+
+TEST_F(AudioRendererImplTest, OnRenderEndOfStream) {

[scherkus (not reviewing), 2012/03/03 02:24:32]

These tests rely way too much on internal knowledge of the class.

The fact that we're adding virtual methods, protected members, and tests with
friend access is a sign that things have started to go awry! The next person who
touches AudioRendererImpl will spend more time updating tests than writing
production code.

It'd be preferable to eliminate the virtual/protected methods and write these
tests using higher-level methods such as Render() and DecodedAudioReady() -- for
example you can set recieved_end_of_stream_ to true by passing in an EOS Buffer
to DecodedAudioReady()

Failing that -- we could also check in your HTML test as a layout test and do
without C++ unit tests

+  // Verifies that we would successfully receive end of stream signal.
+  RendererSetPlaybackRate(1.0f);
+  WaitForIOThreadCompletion();
+  renderer_->set_recieved_end_of_stream(true);
+  EXPECT_CALL(*renderer_, OnRenderEndOfStreamDelay())
+      .WillOnce(Return(0));
+  EXPECT_CALL(*renderer_, SignalEndOfStream());
+  renderer_->OnRenderEndOfStream();
+  WaitForIOThreadCompletion();
+  renderer_->Stop(media::NewExpectedClosure());
+  WaitForIOThreadCompletion();
+}
+
+TEST_F(AudioRendererImplTest, OnRenderEndOfStreamStopped) {
+  // Verifies that we can successfully cancel already scheduled
+  // signaling of end of stream.
+  RendererSetPlaybackRate(1.0f);
+  WaitForIOThreadCompletion();
+  renderer_->set_recieved_end_of_stream(true);
+  EXPECT_CALL(*renderer_, OnRenderEndOfStreamDelay())
+      .WillOnce(Return(100));
+  EXPECT_CALL(*renderer_, SignalEndOfStream())
+      .Times(0);
+  renderer_->OnRenderEndOfStream();
+  RendererSetPlaybackRate(0.0f);
+  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(150));
+  WaitForIOThreadCompletion();
+  renderer_->Stop(media::NewExpectedClosure());
+  WaitForIOThreadCompletion();
+}