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

media/renderers/audio_renderer_impl_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/audio_buffer_converter.h"
@@ skipping 88 matching lines @@
                                           hardware_config_,
                                           new MediaLog()));
   }
 
   virtual ~AudioRendererImplTest() {
     SCOPED_TRACE("~AudioRendererImplTest()");
   }
 
   void ExpectUnsupportedAudioDecoder() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(DoAll(SaveArg<2>(&output_cb_),
-                        RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED)));
+        .WillOnce(DoAll(SaveArg<2>(&output_cb_), RunCallback<1>(false)));
   }
 
   MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
   MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
   MOCK_METHOD1(OnError, void(PipelineStatus));
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
 
   void InitializeRenderer(const PipelineStatusCB& pipeline_status_cb) {
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     renderer_->Initialize(
         &demuxer_stream_, pipeline_status_cb, SetDecryptorReadyCB(),
         base::Bind(&AudioRendererImplTest::OnStatistics,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnBufferingStateChange,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnEnded, base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnError, base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnWaitingForDecryptionKey,
                    base::Unretained(this)));
   }
 
   void Initialize() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(DoAll(SaveArg<2>(&output_cb_),
-                        RunCallback<1>(PIPELINE_OK)));
+        .WillOnce(DoAll(SaveArg<2>(&output_cb_), RunCallback<1>(true)));
     InitializeWithStatus(PIPELINE_OK);
 
     next_timestamp_.reset(new AudioTimestampHelper(kInputSamplesPerSecond));
   }
 
   void InitializeWithStatus(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("InitializeWithStatus(%d)", expected));
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(expected);
 
     // We should have no reads.
     EXPECT_TRUE(decode_cb_.is_null());
   }
 
   void InitializeAndDestroy() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(RunCallback<1>(PIPELINE_OK));
+    EXPECT_CALL(*decoder_, Initialize(_, _, _)).WillOnce(RunCallback<1>(true));
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
 
     // Destroy the |renderer_| before we let the MessageLoop run, this simulates
     // an interleaving in which we end up destroying the |renderer_| while the
     // OnDecoderSelected callback is in flight.
     renderer_.reset();
     event.RunAndWaitForStatus(PIPELINE_ERROR_ABORT);
   }
 
   void InitializeAndDestroyDuringDecoderInit() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _))
         .WillOnce(EnterPendingDecoderInitStateAction(this));
 
     WaitableMessageLoopEvent event;
     InitializeRenderer(event.GetPipelineStatusCB());
     base::RunLoop().RunUntilIdle();
     DCHECK(!init_decoder_cb_.is_null());
 
     renderer_.reset();
     event.RunAndWaitForStatus(PIPELINE_ERROR_ABORT);
   }
 
-  void EnterPendingDecoderInitState(PipelineStatusCB cb) {
+  void EnterPendingDecoderInitState(const AudioDecoder::InitCB& cb) {
     init_decoder_cb_ = cb;
   }
 
   void FlushDuringPendingRead() {
     SCOPED_TRACE("FlushDuringPendingRead()");
     WaitableMessageLoopEvent flush_event;
     renderer_->Flush(flush_event.GetClosure());
     SatisfyPendingRead(InputFrames(256));
     flush_event.RunAndWait();
 
@@ skipping 201 matching lines @@
 
   // Used for satisfying reads.
   AudioDecoder::OutputCB output_cb_;
   AudioDecoder::DecodeCB decode_cb_;
   base::Closure reset_cb_;
   scoped_ptr<AudioTimestampHelper> next_timestamp_;
 
   // Run during DecodeDecoder() to unblock WaitForPendingRead().
   base::Closure wait_for_pending_decode_cb_;
 
-  PipelineStatusCB init_decoder_cb_;
+  AudioDecoder::InitCB init_decoder_cb_;
   bool ended_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
 };
 
 TEST_F(AudioRendererImplTest, Initialize_Successful) {
   Initialize();
 }
 
 TEST_F(AudioRendererImplTest, Initialize_DecoderInitFailure) {
@@ skipping 334 matching lines @@
   // Start rendering with zero playback rate. Sink should be paused until
   // non-zero rate is set.
   renderer_->SetPlaybackRate(0.0);
   renderer_->StartTicking();
   EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
   renderer_->SetPlaybackRate(1.0);
   EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
 }
 
 }  // namespace media