media: Clean up MediaCodecBridge and remove subclasses

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"
@@ skipping 55 matching lines @@
         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));
+            .WillRepeatedly(Return(MEDIA_CODEC_TRY_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(int sdk_int = kLollipop) {
     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(sdk_int, client_.get(),
                                          std::move(codec), task_runner_));
     codec_loop_->SetTestTickClock(&clock_);
     Mock::VerifyAndClearExpectations(client_.get());
   }
 
   // Set an expectation that MCL will try to get another input / output buffer,
   // and not get one in DoPendingWork.
   void ExpectEmptyIOLoop() {
     ExpectIsAnyInputPending(false);
     EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
         .Times(1)
-        .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+        .WillOnce(Return(MEDIA_CODEC_TRY_AGAIN_LATER));
   }
 
   void ExpectIsAnyInputPending(bool pending) {
     EXPECT_CALL(*client_, IsAnyInputPending()).WillOnce(Return(pending));
   }
 
   void ExpectDequeueInputBuffer(int input_buffer_index,
                                 MediaCodecStatus status = MEDIA_CODEC_OK) {
     EXPECT_CALL(Codec(), DequeueInputBuffer(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(input_buffer_index), Return(status)));
@@ skipping 91 matching lines @@
   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.
   ExpectIsAnyInputPending(false);
   EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
       .Times(1)
-      .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+      .WillOnce(Return(MEDIA_CODEC_TRY_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.
   ExpectIsAnyInputPending(true);
   EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _)).Times(1);
@@ skipping 39 matching lines @@
 
     // Now send the EOS back on the output queue.
     EosOutputBuffer eos;
     ExpectDequeueOutputBuffer(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));
+        .WillOnce(Return(MEDIA_CODEC_TRY_AGAIN_LATER));
   }
   codec_loop_->DoPendingWork();
   // Don't WaitUntilIdle() here.  See TestUnqueuedEos.
 }
 
 TEST_F(MediaCodecLoopTest, TestQueueInputData) {
   // Send a buffer full of data into MCL and make sure that it gets queued with
   // MediaCodecBridge correctly.
   ConstructCodecLoop();
   {
     InSequence _s;
 
     ExpectIsAnyInputPending(true);
     int input_buffer_index = 123;
     ExpectDequeueInputBuffer(input_buffer_index);
 
     MediaCodecLoop::InputData data = BigBuckBunny();
     ExpectProvideInputData(data);
 
     // MCL should send the buffer into MediaCodec and notify the client.
     ExpectQueueInputBuffer(input_buffer_index, data);
     ExpectInputDataQueued(true);
 
     // MCL will try to dequeue an output buffer too.
     EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
         .Times(1)
-        .WillOnce(Return(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER));
+        .WillOnce(Return(MEDIA_CODEC_TRY_AGAIN_LATER));
 
     // DoPendingWork will try again.
     ExpectEmptyIOLoop();
   }
   codec_loop_->DoPendingWork();
   WaitUntilIdle(ShouldNotBeIdle);
 }
 
 TEST_F(MediaCodecLoopTest, TestQueueInputDataFails) {
   // Send a buffer full of data into MCL, but MediaCodecBridge fails to queue
@@ skipping 18 matching lines @@
   // MCL is now in the error state.
 }
 
 TEST_F(MediaCodecLoopTest, TestQueueInputDataTryAgain) {
   // Signal that there is input pending, but don't provide an input buffer.
   ConstructCodecLoop();
   {
     InSequence _s;
 
     ExpectIsAnyInputPending(true);
-    ExpectDequeueInputBuffer(-1, MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER);
+    ExpectDequeueInputBuffer(-1, MEDIA_CODEC_TRY_AGAIN_LATER);
     // MCL will try for output too.
-    ExpectDequeueOutputBuffer(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
+    ExpectDequeueOutputBuffer(MEDIA_CODEC_TRY_AGAIN_LATER);
   }
   codec_loop_->DoPendingWork();
   // Note that the client might not be allowed to change from "input pending"
   // to "no input pending" without actually being asked for input.  For now,
   // MCL doesn't assume this.
   WaitUntilIdle(ShouldNotBeIdle);
 }
 
 TEST_F(MediaCodecLoopTest, TestSeveralPendingIOBuffers) {
   // Provide several input and output buffers to MCL.
@@ skipping 60 matching lines @@
     // First DoPendingWork()
     ExpectIsAnyInputPending(true);
     ExpectDequeueInputBuffer(input_buffer_index);
 
     ExpectProvideInputData(data);
 
     // Notify MCL that it's missing the key.
     ExpectQueueInputBuffer(input_buffer_index, data, MEDIA_CODEC_NO_KEY);
 
     // MCL should now try for output buffers.
-    ExpectDequeueOutputBuffer(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
+    ExpectDequeueOutputBuffer(MEDIA_CODEC_TRY_AGAIN_LATER);
 
     // MCL will try again, since trying to queue the input buffer is considered
     // doing work, for some reason.  It would be nice to make this optional.
     // Note that it should not ask us for more input, since it has not yet sent
     // the buffer we just provided.
-    ExpectDequeueOutputBuffer(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
+    ExpectDequeueOutputBuffer(MEDIA_CODEC_TRY_AGAIN_LATER);
   }
   codec_loop_->DoPendingWork();
 
   // Try again, to be sure that MCL doesn't request more input.  Note that this
   // is also done in the above loop, but that one could be made optional.  This
   // forces MCL to try again as part of an entirely new DoPendingWork cycle.
   {
     InSequence _s;
     // MCL should only try for output buffers, since it's still waiting for a
     // key to be added.
-    ExpectDequeueOutputBuffer(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
+    ExpectDequeueOutputBuffer(MEDIA_CODEC_TRY_AGAIN_LATER);
   }
   codec_loop_->DoPendingWork();
 
   // When we add the key, MCL will DoPending work again.  This time, it should
   // succeed since the key has been added.
   {
     InSequence _s;
     // MCL should not retain the original pointer.
     data.memory = nullptr;
     ExpectQueueInputBuffer(input_buffer_index, data);
     ExpectInputDataQueued(true);
-    ExpectDequeueOutputBuffer(MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER);
+    ExpectDequeueOutputBuffer(MEDIA_CODEC_TRY_AGAIN_LATER);
 
     // MCL did work, so it will try again.
     ExpectEmptyIOLoop();
   }
 
   codec_loop_->OnKeyAdded();
   WaitUntilIdle(ShouldNotBeIdle);
 }
 
 }  // namespace media