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

content/renderer/media/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 "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"
 #include "content/renderer/mock_content_renderer_client.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_channel.h"
 #include "media/base/data_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
@@ skipping 27 matching lines @@
 // additional tasks remain in the task queue.
 void WaitCallback(base::WaitableEvent* event) {
   event->Signal();
 }
 
 // Class we would be testing.
 class TestAudioRendererImpl : public AudioRendererImpl {
  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
     : public ::testing::Test,
       public IPC::Channel::Listener {
  public:
   // IPC::Channel::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) {
       NOTIMPLEMENTED();
       return true;
@@ skipping 59 matching lines @@
       base::TimeDelta current_time, base::TimeDelta max_time) {
     CHECK(current_time <= max_time);
   }
 
   media::AudioRenderer::AudioTimeCB NewAudioTimeClosure() {
     return base::Bind(&AudioRendererImplTest::OnAudioTimeCallback,
                       base::Unretained(this));
   }
 
  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(
         FROM_HERE, base::Bind(&WaitCallback, base::Unretained(event_.get())));
     EXPECT_TRUE(event_->TimedWait(
         base::TimeDelta::FromMilliseconds(TestTimeouts::action_timeout_ms())));
   }
 
   MessageLoopForIO message_loop_;
   content::MockContentRendererClient mock_content_renderer_client_;
   scoped_ptr<IPC::Channel> channel_;
   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:
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
 };
 
 const int AudioRendererImplTest::kSize = 1024;
 
 TEST_F(AudioRendererImplTest, SetPlaybackRate) {
   // Execute SetPlaybackRate() codepath by toggling play/pause.
@@ skipping 24 matching lines @@
   base::Time time_now = base::Time();  // Null time by default.
   renderer_->set_earliest_end_time(time_now);
   renderer_->UpdateEarliestEndTime(renderer_->bytes_per_second(),
                                    base::TimeDelta::FromMilliseconds(100),
                                    time_now);
   int time_delta = (renderer_->earliest_end_time() - time_now).InMilliseconds();
   EXPECT_EQ(1100, time_delta);
   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();
+}