media: Reland "Simplify {Audio|Video}Decoder initialization callback."

media/renderers/video_renderer_impl_unittest.cc

 // Copyright 2013 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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/stack_trace.h"
@@ skipping 79 matching lines @@
 
   void InitializeWithLowDelay(bool low_delay) {
     // Monitor decodes from the decoder.
     EXPECT_CALL(*decoder_, Decode(_, _))
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::DecodeRequested));
 
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::FlushRequested));
 
     // Initialize, we shouldn't have any reads.
-    InitializeRenderer(PIPELINE_OK, low_delay);
+    InitializeRenderer(low_delay, true);
   }
 
-  void InitializeRenderer(PipelineStatus expected, bool low_delay) {
-    SCOPED_TRACE(base::StringPrintf("InitializeRenderer(%d)", expected));
+  void InitializeRenderer(bool low_delay, bool expect_to_success) {
+    SCOPED_TRACE(
+        base::StringPrintf("InitializeRenderer(%d)", expect_to_success));
     WaitableMessageLoopEvent event;
-    CallInitialize(event.GetPipelineStatusCB(), low_delay, expected);
-    event.RunAndWaitForStatus(expected);
+    CallInitialize(event.GetPipelineStatusCB(), low_delay, expect_to_success);
+    event.RunAndWaitForStatus(expect_to_success ? PIPELINE_OK
+                                                : DECODER_ERROR_NOT_SUPPORTED);
   }
 
   void CallInitialize(const PipelineStatusCB& status_cb,
                       bool low_delay,
-                      PipelineStatus decoder_status) {
+                      bool expect_to_success) {
     if (low_delay)
       demuxer_stream_.set_liveness(DemuxerStream::LIVENESS_LIVE);
     EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
         .WillOnce(
-            DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(decoder_status)));
+            DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(expect_to_success)));
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     renderer_->Initialize(
         &demuxer_stream_, status_cb, media::SetDecryptorReadyCB(),
         base::Bind(&VideoRendererImplTest::OnStatisticsUpdate,
                    base::Unretained(this)),
         base::Bind(&StrictMock<MockCB>::BufferingStateChange,
                    base::Unretained(&mock_cb_)),
         ended_event_.GetClosure(), error_event_.GetPipelineStatusCB(),
         base::Bind(&WallClockTimeSource::GetWallClockTimes,
                    base::Unretained(&time_source_)),
@@ skipping 395 matching lines @@
   EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
   StartPlayingFrom(0);
 
   // Check that there is an outstanding Read() request.
   EXPECT_TRUE(IsReadPending());
 
   Destroy();
 }
 
 TEST_P(VideoRendererImplTest, VideoDecoder_InitFailure) {
-  InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED, false);
+  InitializeRenderer(false, false);
   Destroy();
 }
 
 TEST_P(VideoRendererImplTest, Underflow) {
   Initialize();
   QueueFrames("0 30 60 90");
 
   {
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
@@ skipping 171 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(OldVideoRenderer,
                         VideoRendererImplTest,
                         testing::Values(false));
 INSTANTIATE_TEST_CASE_P(NewVideoRenderer,
                         VideoRendererImplTest,
                         testing::Values(true));
 
 }  // namespace media