refactoring decoder interface

media/filters/decoder_base_unittest.cc

 // Copyright (c) 2010 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 <vector>
 
 #include "media/base/mock_filters.h"
 #include "media/filters/decoder_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
 using ::testing::NotNull;
 using ::testing::StrictMock;
 
 namespace media {
 
 class GTEST_TEST_CLASS_NAME_(DecoderBaseTest, FlowControl);
 
 }  // namespace media
 
 namespace {
 
 class MockDecoderOutput : public media::StreamSample {
  public:
   MOCK_CONST_METHOD0(IsEndOfStream, bool());
 };
 
-class MockDecoder : public media::MediaFilter {};
-
 class MockBuffer : public media::Buffer {
  public:
   MockBuffer() {}
   virtual ~MockBuffer() {}
   MOCK_CONST_METHOD0(GetData, const uint8*());
   MOCK_CONST_METHOD0(GetDataSize, size_t());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBuffer);
 };
 
+class MockDecoder : public media::MediaFilter {
+ public:
+  typedef Callback1<scoped_refptr<MockDecoderOutput> >::Type
+      FillBufferDoneCallback;
+  void set_fill_buffer_done_callback_(FillBufferDoneCallback* callback) {
+    fill_buffer_done_callback_.reset(callback);
+  }
+  FillBufferDoneCallback* fill_buffer_done_callback() {
+    return fill_buffer_done_callback_.get();
+  }
+  scoped_ptr<FillBufferDoneCallback> fill_buffer_done_callback_;
+};
+
+class MockDecoderCallback {
+ public:
+  MOCK_METHOD1(OnReadComplete, void(scoped_refptr<MockDecoderOutput> output));
+};
+
 class MockDecoderImpl : public media::DecoderBase<
   MockDecoder, MockDecoderOutput> {
  public:
   MockDecoderImpl() {
     media_format_.SetAsString(media::MediaFormat::kMimeType, "mock");
   }
 
   virtual ~MockDecoderImpl() {}
 
   // DecoderBase Implementations.
   MOCK_METHOD3(DoInitialize,
                void(media::DemuxerStream* demuxer_stream,
                     bool* success,
                     Task* done_cb));
   MOCK_METHOD0(DoStop, void());
   MOCK_METHOD2(DoSeek, void(base::TimeDelta time, Task* done_cb));
   MOCK_METHOD1(DoDecode, void(media::Buffer* input));
 
  private:
   FRIEND_TEST(media::DecoderBaseTest, FlowControl);
 
   DISALLOW_COPY_AND_ASSIGN(MockDecoderImpl);
 };
 
-class MockDecoderReadCallback {
- public:
-  MockDecoderReadCallback() {}
-  virtual ~MockDecoderReadCallback() {}
-  MOCK_METHOD1(ReadCallback, void(MockDecoderOutput* output));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockDecoderReadCallback);
-};
-
 }  // namespace
 
 namespace media {
 
 ACTION(Initialize) {
   AutoTaskRunner done_runner(arg2);
   *arg1 = true;
 }
 
 ACTION_P(SaveDecodeRequest, list) {
@@ skipping 15 matching lines @@
 //   \ DoDecode() -> Decoder
 // - ReadCallback() -> DecoderBase
 //   \ DoDecode() -> Decoder
 // - DecodeCallback() -> DecoderBase
 //   \ ReadCallback() -> client
 // - DecodeCallback() -> DecoderBase
 //   \ ReadCallback() -> client
 TEST(DecoderBaseTest, FlowControl) {
   MessageLoop message_loop;
   scoped_refptr<MockDecoderImpl> decoder = new MockDecoderImpl();
+  MockDecoderCallback read_callback;
+  decoder->set_fill_buffer_done_callback_(
+      NewCallback(&read_callback, &MockDecoderCallback::OnReadComplete));
   scoped_refptr<MockDemuxerStream> demuxer_stream = new MockDemuxerStream();
   StrictMock<MockFilterCallback> callback;
   decoder->set_message_loop(&message_loop);
 
   // Initailize.
   EXPECT_CALL(callback, OnFilterCallback());
   EXPECT_CALL(callback, OnCallbackDestroyed());
   EXPECT_CALL(*decoder, DoInitialize(NotNull(), NotNull(), NotNull()))
       .WillOnce(Initialize());
   decoder->Initialize(demuxer_stream.get(), callback.NewCallback());
   message_loop.RunAllPending();
 
   // Read.
-  StrictMock<MockDecoderReadCallback> read_callback;
   std::vector<scoped_refptr<Buffer> > decode_requests;
   EXPECT_CALL(*demuxer_stream, Read(NotNull()))
       .Times(2)
       .WillRepeatedly(CompleteDemuxRequest());
   EXPECT_CALL(*decoder, DoDecode(NotNull()))
       .Times(2)
       .WillRepeatedly(SaveDecodeRequest(&decode_requests));
-  decoder->Read(
-      NewCallback(reinterpret_cast<MockDecoderReadCallback*>(&read_callback),
-                  &MockDecoderReadCallback::ReadCallback));
-  decoder->Read(
-      NewCallback(reinterpret_cast<MockDecoderReadCallback*>(&read_callback),
-                  &MockDecoderReadCallback::ReadCallback));
+  scoped_refptr<MockDecoderOutput> output;
+  decoder->FillThisBuffer(output);
+  decoder->FillThisBuffer(output);
   message_loop.RunAllPending();
 
   // Fulfill the decode request.
-  EXPECT_CALL(read_callback, ReadCallback(NotNull())).Times(2);
+  EXPECT_CALL(read_callback, OnReadComplete(_)).Times(2);
   for (size_t i = 0; i < decode_requests.size(); ++i) {
     decoder->EnqueueResult(new MockDecoderOutput());
     decoder->OnDecodeComplete();
   }
   decode_requests.clear();
   message_loop.RunAllPending();
 
   // Stop.
   EXPECT_CALL(*decoder, DoStop());
   decoder->Stop();
   message_loop.RunAllPending();
 }
 
 }  // namespace media