MediaCodecLoop unit tests

media/base/android/media_codec_loop_unittest.cc

 // Copyright 2016 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/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_codec_loop.h"
+#include "media/base/android/mock_media_codec_bridge.h"
+#include "media/base/fake_single_thread_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Eq;
+using ::testing::Field;
+using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+using ::testing::StrictMock;
+
 namespace media {
 
-class MockMediaCodecLoopClient : public MediaCodecLoop::Client {
+// The client is a strict mock, since we don't want random calls into it.  We
+// want to be sure about the call sequence.
+class MockMediaCodecLoopClient : public StrictMock<MediaCodecLoop::Client> {
  public:
   MOCK_CONST_METHOD0(IsAnyInputPending, bool());
   MOCK_METHOD0(ProvideInputData, MediaCodecLoop::InputData());
   MOCK_METHOD1(OnDecodedEos, void(const MediaCodecLoop::OutputBuffer&));
   MOCK_METHOD1(OnDecodedFrame, bool(const MediaCodecLoop::OutputBuffer&));
   MOCK_METHOD0(OnOutputFormatChanged, bool());
   MOCK_METHOD0(OnCodecLoopError, void());
 };
 
 class MediaCodecLoopTest : public testing::Test {
  public:
-  MediaCodecLoopTest() : client_(new MockMediaCodecLoopClient) {}
+  MediaCodecLoopTest()
+      : client_(new StrictMock<MockMediaCodecLoopClient>()),
+        task_runner_(new FakeSingleThreadTaskRunner(&clock_)) {}
+
+  ~MediaCodecLoopTest() override {}
+
+ protected:
+  enum IdleExpectation {
+    ShouldBeIdle,
+    ShouldNotBeIdle,
+  };
+
+  // Wait until |codec_loop_| is idle.
+  void WaitUntilIdle(IdleExpectation idleExpectation = ShouldBeIdle) {
+    switch (idleExpectation) {
+      case ShouldBeIdle:
+        EXPECT_CALL(*client_, IsAnyInputPending()).Times(0);
+        EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _)).Times(0);
+        break;
+      case ShouldNotBeIdle:
+        // Expect at least one call to see if more work is ready.  We will
+        // return 'no'.
+        EXPECT_CALL(*client_, IsAnyInputPending())
+            .Times(AtLeast(1))
+            .WillRepeatedly(Return(false));
+        EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
+            .Times(AtLeast(1))
+            .WillRepeatedly(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+        break;
+    }
+
+    // Either way, we expect that MCL should not attempt to dequeue input
+    // buffers, either because it's idle or because we said that no input
+    // is pending.
+    EXPECT_CALL(Codec(), DequeueInputBuffer(_, _)).Times(0);
+
+    // TODO(liberato): assume that MCL doesn't retry for 30 seconds.  Note
+    // that this doesn't actually wall-clock wait.
+    task_runner_->Sleep(base::TimeDelta::FromSeconds(30));
+  }
+
+  void ConstructCodecLoop() {
+    std::unique_ptr<MediaCodecBridge> codec(new MockMediaCodecBridge());
+    // Since we're providing a codec, we do not expect an error.
+    EXPECT_CALL(*client_, OnCodecLoopError()).Times(0);
+    codec_loop_.reset(
+        new MediaCodecLoop(client_.get(), std::move(codec), task_runner_));
+    codec_loop_->SetTestTickClock(&clock_);
+    Mock::VerifyAndClearExpectations(client_.get());
+    // We might want to WaitUntilIdle here.
+  }
+
+  struct OutputBuffer {
+    int index = 1;
+    size_t offset = 0;
+    size_t size = 1024;
+    base::TimeDelta pts = base::TimeDelta::FromSeconds(1);
+    bool eos = false;
+    bool key_frame = true;
+  };
+
+  struct EosOutputBuffer : public OutputBuffer {
+    EosOutputBuffer() { eos = true; }
+  };
+
+  void QueueOutputBuffer(OutputBuffer buffer) {
+    EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
+        .WillOnce(DoAll(
+            SetArgPointee<1>(buffer.index), SetArgPointee<2>(buffer.offset),
+            SetArgPointee<3>(buffer.size), SetArgPointee<4>(buffer.pts),
+            SetArgPointee<5>(buffer.eos), SetArgPointee<6>(buffer.key_frame),
+            Return(MEDIA_CODEC_OK)));
+  }
+
+  MockMediaCodecBridge& Codec() {
+    return *static_cast<MockMediaCodecBridge*>(codec_loop_->GetCodec());
+  }
 
  public:
   std::unique_ptr<MediaCodecLoop> codec_loop_;
   std::unique_ptr<MockMediaCodecLoopClient> client_;
+  // TODO: how is the lifecycle of |clock_| handled?  |task_runner_| can outlive
+  // us, since it's a refptr.
+  base::SimpleTestTickClock clock_;
+  scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecLoopTest);
 };
 
 TEST_F(MediaCodecLoopTest, TestConstructionWithNullCodec) {
   std::unique_ptr<MediaCodecBridge> codec;
   EXPECT_CALL(*client_, OnCodecLoopError()).Times(1);
   codec_loop_.reset(new MediaCodecLoop(client_.get(), std::move(codec)));
+  // Do not WaitUntilIdle() here, since that assumes that we have a codec.
 
   ASSERT_FALSE(codec_loop_->GetCodec());
 }
 
+TEST_F(MediaCodecLoopTest, TestConstructionWithCodec) {
+  ConstructCodecLoop();
+  ASSERT_EQ(codec_loop_->GetCodec(), &Codec());
+  WaitUntilIdle(ShouldBeIdle);
+}
+
+TEST_F(MediaCodecLoopTest, TestPendingWorkWithoutInput) {
+  ConstructCodecLoop();
+  // MCL should try ask if there is pending input, and try to dequeue output.
+  EXPECT_CALL(*client_, IsAnyInputPending()).Times(1).WillOnce(Return(false));
+  EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
+      .Times(1)
+      .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+  codec_loop_->DoPendingWork();
+  WaitUntilIdle(ShouldNotBeIdle);
+}
+
+TEST_F(MediaCodecLoopTest, TestPendingWorkWithInput) {
+  ConstructCodecLoop();
+  // MCL should try ask if there is pending input, and try to dequeue both an
+  // output and input buffer.
+  EXPECT_CALL(*client_, IsAnyInputPending()).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _)).Times(1);
+  EXPECT_CALL(Codec(), DequeueInputBuffer(_, _)).Times(1);
+  codec_loop_->DoPendingWork();
+  WaitUntilIdle(ShouldNotBeIdle);
+}
+
+TEST_F(MediaCodecLoopTest, TestPendingWorkWithOutputBuffer) {
+  ConstructCodecLoop();
+  {
+    InSequence _s;
+
+    // MCL will first request input, then try to dequeue output.
+    EXPECT_CALL(*client_, IsAnyInputPending()).WillOnce(Return(false));
+    OutputBuffer buf;
+    QueueOutputBuffer(buf);
+    EXPECT_CALL(*client_,

[liberato (no reviews please), 2016/07/08 17:49:46]

gmock is really amazing.  it lets me set an expectation that insists that
|index| of the provided OutputBuffer matches what we think it should be.

+                OnDecodedFrame(
+                    Field(&MediaCodecLoop::OutputBuffer::index, Eq(buf.index))))
+        .Times(1)
+        .WillOnce(Return(true));
+
+    // MCL will try again for another set of buffers before DoPendingWork()
+    // returns.  This is why we don't just leave them for WaitUntilIdle().
+    EXPECT_CALL(*client_, IsAnyInputPending()).WillOnce(Return(false));
+    EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
+        .Times(1)
+        .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+  }
+  codec_loop_->DoPendingWork();
+  WaitUntilIdle(ShouldNotBeIdle);
+}
+
+TEST_F(MediaCodecLoopTest, TestUnqueuedEos) {
+  // Test sending an unsolicited EOS from MCB to MCL.
+  ConstructCodecLoop();
+  {
+    InSequence _s;
+
+    // MCL will first request input, then try to dequeue output.
+    EXPECT_CALL(*client_, IsAnyInputPending()).WillOnce(Return(false));
+    EosOutputBuffer eos;
+    QueueOutputBuffer(eos);
+    EXPECT_CALL(Codec(), ReleaseOutputBuffer(eos.index, false));
+    EXPECT_CALL(*client_, OnDecodedEos(_)).Times(1);
+
+    // MCL should not call back for another input buffer once it receives EOS,
+    // so don't expect a call to IsAnyInputPending.  It will try for more
+    // output, however.  It's unclear if it should.
+    EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
+        .Times(1)
+        .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+  }
+  codec_loop_->DoPendingWork();
+  // Don't WaitUntilIdle() here, since MCL is not requesting buffers.  It would
+  // fail the IsAnyInputPending expectation.
+}
+
+TEST_F(MediaCodecLoopTest, TestQueueEos) {
+  // Test sending an unsolicited EOS from MCB to MCL.
+  ConstructCodecLoop();
+  {
+    InSequence _s;
+
+    // MCL will first request input.  We will provide an EOS from the client,
+    // and an input buffer to hold it.
+    EXPECT_CALL(*client_, IsAnyInputPending()).WillOnce(Return(true));
+    int input_buffer_index = 123;
+    EXPECT_CALL(Codec(), DequeueInputBuffer(_, _))
+        .WillOnce(DoAll(SetArgPointee<1>(input_buffer_index),

[liberato (no reviews please), 2016/07/08 17:49:46]

this sets the *index parameter of DequeueInputBuffer to |input_buffer_index| as
a side-effect of the expectation.

+                        Return(MEDIA_CODEC_OK)));
+    MediaCodecLoop::InputData data;
+    data.is_eos = true;
+    EXPECT_CALL(*client_, ProvideInputData()).WillOnce(Return(data));
+    EXPECT_CALL(Codec(), QueueEOS(input_buffer_index));
+
+    // Now send the EOS back on the output queue.
+    EosOutputBuffer eos;
+    QueueOutputBuffer(eos);
+    EXPECT_CALL(Codec(), ReleaseOutputBuffer(eos.index, false));
+    EXPECT_CALL(*client_, OnDecodedEos(_)).Times(1);
+
+    // See TestUnqueuedEos.
+    EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
+        .Times(1)
+        .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+  }
+  codec_loop_->DoPendingWork();
+  // Don't WaitUntilIdle() here.  See TestUnqueuedEos.
+}
+
 }  // namespace media