Moved codec-specific audio packet splitting into decoders.

webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc

Index: webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc
diff --git a/webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc b/webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc
index f0b16d06aa558c3898951a1326126bf81d836510..a1d0dfe3f0998a5aa7a7959a52e317d1e0a3e934 100644
--- a/webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/payload_splitter_unittest.cc
@@ -155,7 +155,7 @@ void VerifyPacket(const Packet* packet,
   EXPECT_EQ(primary, packet->primary);
   ASSERT_FALSE(packet->payload == NULL);
   for (size_t i = 0; i < packet->payload_length; ++i) {
-    EXPECT_EQ(payload_value, packet->payload[i]);
+    ASSERT_EQ(payload_value, packet->payload[i]);

[kwiberg-webrtc, 2016/08/26 12:39:25]

The caller of VerifyPacket doesn't call ASSERT/EXPECT_NO_FATAL_FAILURES, so it's
probably better to just EXPECT. See
https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuid....

[ossu, 2016/08/26 13:05:30]

Well you'll get one roughly one trillion errors during a failing test, rather
than only the first one. The line just before the for-loop does ASSERT_FALSE, so
an assert could already happen.

[kwiberg-webrtc, 2016/08/26 22:05:13]

OK. But then the callers ought to use ASSERT_NO_FATAL_FAILURES.

   }
 }
 
@@ -370,34 +370,56 @@ TEST(AudioPayloadSplitter, NonSplittable) {
     packet_list.push_back(CreatePacket(i, kPayloadLength, 10 * i));
   }
 
+  class NoOpAudioDecoder : public AudioDecoder {
+   public:
+    void Reset() override { }
+    int SampleRateHz() const override { return 8000; }
+    size_t Channels() const override { return 1; }
+
+   private:
+    int DecodeInternal(const uint8_t* encoded,
+                       size_t encoded_len,
+                       int sample_rate_hz,
+                       int16_t* decoded,
+                       SpeechType* speech_type) override
+    { return 0; }
+  };
+
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
+  std::unique_ptr<AudioDecoder> external_decoder(new NoOpAudioDecoder);
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   std::unique_ptr<DecoderDatabase::DecoderInfo> info0(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISAC, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(info0.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info1(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderISACswb, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
       .WillRepeatedly(Return(info1.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info2(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderRED, "", factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(2))
       .WillRepeatedly(Return(info2.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info3(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderAVT, "", factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(3))
       .WillRepeatedly(Return(info3.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info4(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderCNGnb, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(4))
       .WillRepeatedly(Return(info4.get()));
   std::unique_ptr<DecoderDatabase::DecoderInfo> info5(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderArbitrary, "",
+                                       external_decoder.get()));
   EXPECT_CALL(decoder_database, GetDecoderInfo(5))
-      .WillRepeatedly(Return(info5.get()));
+     .WillRepeatedly(Return(info5.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
@@ -527,13 +549,15 @@ TEST_P(SplitBySamplesTest, PayloadSizes) {
                                        payload_size_ms));
   }
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   // (Sample rate is set to 8000 Hz, but does not matter.)
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(decoder_type_, ""));
+      new DecoderDatabase::DecoderInfo(decoder_type_, "", factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
@@ -615,12 +639,15 @@ TEST_P(SplitIlbcTest, NumFrames) {
   }
   packet_list.push_back(packet);
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
@@ -681,14 +708,17 @@ TEST(IlbcPayloadSplitter, TooLargePayload) {
   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
   packet_list.push_back(packet);
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   MockDecoderDatabase decoder_database;
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
-  EXPECT_EQ(PayloadSplitter::kTooLargePayload,
+  EXPECT_EQ(PayloadSplitter::kFrameSplitError,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
@@ -712,9 +742,12 @@ TEST(IlbcPayloadSplitter, UnevenPayload) {
   Packet* packet = CreatePacket(kPayloadType, kPayloadLengthBytes, 0);
   packet_list.push_back(packet);
 
+  rtc::scoped_refptr<AudioDecoderFactory> factory =
+      CreateBuiltinAudioDecoderFactory();
   MockDecoderDatabase decoder_database;
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
-      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
+      new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, "",
+                                       factory));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));