media: Fix MojoAudioDecoder reinitialization

media/mojo/clients/mojo_audio_decoder_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 <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 90 matching lines @@
   }
 
   void ConnectToService(mojom::AudioDecoderRequest request) {
     DCHECK(service_task_runner_->BelongsToCurrentThread());
 
     std::unique_ptr<StrictMock<MockAudioDecoder>> mock_audio_decoder(
         new StrictMock<MockAudioDecoder>());
     mock_audio_decoder_ = mock_audio_decoder.get();
 
     EXPECT_CALL(*mock_audio_decoder_, Initialize(_, _, _, _))
-        .WillOnce(DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(true)));
+        .WillRepeatedly(DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(true)));
     EXPECT_CALL(*mock_audio_decoder_, Decode(_, _))
         .WillRepeatedly(
             DoAll(InvokeWithoutArgs(this, &MojoAudioDecoderTest::ReturnOutput),
                   RunCallback<1>(DecodeStatus::OK)));
+    EXPECT_CALL(*mock_audio_decoder_, Reset(_))
+        .WillRepeatedly(RunCallback<0>());
 
     mojo::MakeStrongBinding(base::MakeUnique<MojoAudioDecoderService>(
                                 mojo_cdm_service_context_.GetWeakPtr(),
                                 std::move(mock_audio_decoder)),
                             std::move(request));
   }
 
   void InitializeAndExpect(bool success) {
     DVLOG(1) << __func__ << ": success=" << success;
     EXPECT_CALL(*this, OnInitialized(success))
         .WillOnce(InvokeWithoutArgs(this, &MojoAudioDecoderTest::QuitLoop));
 
     AudioDecoderConfig audio_config(kCodecVorbis, kSampleFormat, kChannelLayout,
                                     kDefaultSampleRate, EmptyExtraData(),
                                     Unencrypted());
 
     mojo_audio_decoder_->Initialize(
         audio_config, nullptr, base::Bind(&MojoAudioDecoderTest::OnInitialized,
                                           base::Unretained(this)),
         base::Bind(&MojoAudioDecoderTest::OnOutput, base::Unretained(this)));
 
     RunLoop();
   }
 
   void Initialize() { InitializeAndExpect(true); }
 
+  void Reset() {
+    DVLOG(1) << __func__;
+    EXPECT_CALL(*this, OnReset())
+        .WillOnce(InvokeWithoutArgs(this, &MojoAudioDecoderTest::QuitLoop));
+
+    mojo_audio_decoder_->Reset(
+        base::Bind(&MojoAudioDecoderTest::OnReset, base::Unretained(this)));
+    RunLoop();
+  }
+
   void ReturnOutput() {
     for (int i = 0; i < kOutputPerDecode; ++i) {
       scoped_refptr<AudioBuffer> audio_buffer = MakeAudioBuffer<float>(
           kSampleFormat, kChannelLayout, kChannels, kDefaultSampleRate, 1.0,
           0.0f, 100, input_timestamp_helper_.GetTimestamp());
       input_timestamp_helper_.AddFrames(kDefaultFrameSize);
       output_cb_.Run(audio_buffer);
     }
   }
 
@@ skipping 52 matching lines @@
   int decode_count_ = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MojoAudioDecoderTest);
 };
 
 TEST_F(MojoAudioDecoderTest, Initialize_Success) {
   Initialize();
 }
 
+TEST_F(MojoAudioDecoderTest, Reinitialize_Success) {
+  Initialize();
+  DecodeMultipleTimes(10);
+  Reset();
+
+  // Reinitialize MojoAudioDecoder.
+  Initialize();
+}
+
 // Makes sure all callbacks and client calls are called in order. See
 // http://crbug.com/646054
 TEST_F(MojoAudioDecoderTest, Decode_MultipleTimes) {
   Initialize();
 
   // Choose a large number of decodes per test on purpose to expose potential
   // out of order delivery of mojo messages. See http://crbug.com/646054
   DecodeMultipleTimes(100);
 }
 
 // TODO(xhwang): Add more tests.
 
 }  // namespace media