Added a ParsePayload method to AudioDecoder.

webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 773 matching lines @@
       static_cast<size_t>(10 * kSampleRateHz / 1000);  // 10 ms.
   const size_t kPayloadLengthBytes = 1;
   uint8_t payload[kPayloadLengthBytes] = {0};
   int16_t dummy_output[kPayloadLengthSamples * kChannels] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
-  class MockAudioDecoder : public AudioDecoder {
-   public:
-    // TODO(nisse): Valid overrides commented out, because the gmock
-    // methods don't use any override declarations, and we want to avoid
-    // warnings from -Winconsistent-missing-override. See
-    // http://crbug.com/428099.

[hlundin-webrtc, 2016/09/09 12:11:50]

You may want to link the CL to this bug.

[ossu, 2016/09/12 10:31:37]

Alright, makes sense!

-    void Reset() /* override */ {}
-    MOCK_CONST_METHOD2(PacketDuration, int(const uint8_t*, size_t));
-    MOCK_METHOD5(DecodeInternal, int(const uint8_t*, size_t, int, int16_t*,
-                                     SpeechType*));
-    int SampleRateHz() const /* override */ { return kSampleRateHz; }
-    size_t Channels() const /* override */ { return kChannels; }
-  } decoder_;
+  ::testing::NiceMock<MockAudioDecoder> decoder;
 
   const uint8_t kFirstPayloadValue = 1;
   const uint8_t kSecondPayloadValue = 2;
 
-  EXPECT_CALL(decoder_, PacketDuration(Pointee(kFirstPayloadValue),
-                                       kPayloadLengthBytes))
-    .Times(AtLeast(1))
-    .WillRepeatedly(Return(kNetEqMaxFrameSize + 1));
+  EXPECT_CALL(decoder,
+              PacketDuration(Pointee(kFirstPayloadValue), kPayloadLengthBytes))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(kNetEqMaxFrameSize + 1));
 
-  EXPECT_CALL(decoder_,
-              DecodeInternal(Pointee(kFirstPayloadValue), _, _, _, _))
+  EXPECT_CALL(decoder, DecodeInternal(Pointee(kFirstPayloadValue), _, _, _, _))
       .Times(0);
 
-  EXPECT_CALL(decoder_, DecodeInternal(Pointee(kSecondPayloadValue),
-                                       kPayloadLengthBytes,
-                                       kSampleRateHz, _, _))
+  EXPECT_CALL(decoder, DecodeInternal(Pointee(kSecondPayloadValue),
+                                      kPayloadLengthBytes, kSampleRateHz, _, _))
       .Times(1)
-      .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
-                                          dummy_output +
-                                          kPayloadLengthSamples * kChannels),
-                      SetArgPointee<4>(AudioDecoder::kSpeech),
-                      Return(static_cast<int>(
-                          kPayloadLengthSamples * kChannels))));
+      .WillOnce(DoAll(
+          SetArrayArgument<3>(dummy_output,
+                              dummy_output + kPayloadLengthSamples * kChannels),
+          SetArgPointee<4>(AudioDecoder::kSpeech),
+          Return(static_cast<int>(kPayloadLengthSamples * kChannels))));
 
-  EXPECT_CALL(decoder_, PacketDuration(Pointee(kSecondPayloadValue),
-                                       kPayloadLengthBytes))
-    .Times(AtLeast(1))
-    .WillRepeatedly(Return(kNetEqMaxFrameSize));
+  EXPECT_CALL(decoder,
+              PacketDuration(Pointee(kSecondPayloadValue), kPayloadLengthBytes))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(kNetEqMaxFrameSize));
+
+  EXPECT_CALL(decoder, SampleRateHz())
+      .WillRepeatedly(Return(kSampleRateHz));
+
+  EXPECT_CALL(decoder, Channels())
+      .WillRepeatedly(Return(kChannels));
 
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
-                            &decoder_, NetEqDecoder::kDecoderPCM16B,
+                            &decoder, NetEqDecoder::kDecoderPCM16B,
                             "dummy name", kPayloadType));
 
   // Insert one packet.
   payload[0] = kFirstPayloadValue;  // This will make Decode() fail.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   // Insert another packet.
   payload[0] = kSecondPayloadValue;  // This will make Decode() successful.
   rtp_header.header.sequenceNumber++;
@@ skipping 13 matching lines @@
   // Output size and number of channels should be correct.
   const size_t kExpectedOutputSize = 10 * (kSampleRateHz / 1000) * kChannels;
   EXPECT_EQ(kExpectedOutputSize, output.samples_per_channel_ * kChannels);
   EXPECT_EQ(kChannels, output.num_channels_);
 
   // Second call to GetAudio will decode the packet that is ok. No errors are
   // expected.
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kExpectedOutputSize, output.samples_per_channel_ * kChannels);
   EXPECT_EQ(kChannels, output.num_channels_);
+
+  // Die isn't called through NiceMock (since it's called by the
+  // MockAudioDecoder constructor), so it needs to be mocked explicitly.
+  EXPECT_CALL(decoder, Die());
 }
 
 // This test inserts packets until the buffer is flushed. After that, it asks
 // NetEq for the network statistics. The purpose of the test is to make sure
 // that even though the buffer size increment is negative (which it becomes when
 // the packet causing a flush is inserted), the packet length stored in the
 // decision logic remains valid.
 TEST_F(NetEqImplTest, FloodBufferAndGetNetworkStats) {
   UseNoMocks();
   CreateInstance();
@@ skipping 548 matching lines @@
   EXPECT_CALL(*mock_delay_manager_, BufferLimits(_, _))
       .Times(1)
       .WillOnce(DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2)));
 
   bool muted;
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kAccelerate, neteq_->last_operation_for_test());
 }
 
 }// namespace webrtc