Move Renderer permanent callbacks into RendererClient interface.

media/renderers/renderer_impl_unittest.cc

 // Copyright 2014 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 <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 }
 
 ACTION_P2(AudioError, cb, error) {
   cb->Run(error);
 }
 
 class RendererImplTest : public ::testing::Test {
  public:
   // Used for setting expectations on pipeline callbacks. Using a StrictMock
   // also lets us test for missing callbacks.
-  class CallbackHelper {
+  class CallbackHelper : public RendererClient {
    public:
     CallbackHelper() {}
     virtual ~CallbackHelper() {}
 
+    // RendererClient implementation.
+    MOCK_METHOD1(OnError, void(PipelineStatus status));
+    MOCK_METHOD0(OnEnded, void());
+    MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
+    MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
+    MOCK_METHOD0(OnWaitingForDecryptionKey, void());

[xhwang, 2016/05/09 18:13:23]

Can you use the new MockRendererClient with StrictMock?

[alokp, 2016/05/09 21:31:44]

Do you mean derive from MockRendererClient instead of RendererClient so that we
do not have to mock these functions again?

[xhwang, 2016/05/12 20:51:18]

The reason we use CallbackHelper is that we can use StrictMock on it to check
missing callbacks. Now we already have a MockRendererClient, we should be able
to use StrictMock<MockRendererClient> member directly, similar to these below:

std::unique_ptr<StrictMock<MockDemuxer>> demuxer_;
StrictMock<MockVideoRenderer>* video_renderer_;

Please use MockRendererClient in other tests as well where applicable.

+
+    // Completion callbacks.
     MOCK_METHOD1(OnInitialize, void(PipelineStatus));
     MOCK_METHOD0(OnFlushed, void());
-    MOCK_METHOD0(OnEnded, void());
-    MOCK_METHOD1(OnError, void(PipelineStatus));
-    MOCK_METHOD1(OnUpdateStatistics, void(const PipelineStatistics&));
-    MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
-    MOCK_METHOD0(OnWaitingForDecryptionKey, void());
     MOCK_METHOD1(OnCdmAttached, void(bool));
 
    private:
     DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
   };
 
   RendererImplTest()
       : demuxer_(new StrictMock<MockDemuxer>()),
         video_renderer_(new StrictMock<MockVideoRenderer>()),
         audio_renderer_(new StrictMock<MockAudioRenderer>()),
@@ skipping 31 matching lines @@
   void SetAudioRendererInitializeExpectations(PipelineStatus status) {
     EXPECT_CALL(*audio_renderer_,
                 Initialize(audio_stream_.get(), _, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<4>(&audio_buffering_state_cb_),
                         SaveArg<5>(&audio_ended_cb_),
                         SaveArg<6>(&audio_error_cb_), RunCallback<1>(status)));
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void SetVideoRendererInitializeExpectations(PipelineStatus status) {
-    EXPECT_CALL(*video_renderer_,
-                Initialize(video_stream_.get(), _, _, _, _, _, _, _, _))
+    EXPECT_CALL(*video_renderer_, Initialize(_, video_stream_.get(), _, _, _))
         .WillOnce(DoAll(SaveArg<4>(&video_buffering_state_cb_),
                         SaveArg<5>(&video_ended_cb_), RunCallback<1>(status)));
   }
 
   void InitializeAndExpect(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnInitialize(start_status))
         .WillOnce(SaveArg<0>(&initialization_status_));
     EXPECT_CALL(callbacks_, OnWaitingForDecryptionKey()).Times(0);
 
     if (start_status == PIPELINE_OK && audio_stream_) {
@@ skipping 599 matching lines @@
       .WillOnce(
           SetBufferingState(&audio_buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(*video_renderer_, StartPlayingFrom(kStartTime));
   renderer_impl_->StartPlayingFrom(kStartTime);
 
   // Nothing else should primed on the message loop.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media