Stopped using the NetEqDecoder enum internally in NetEq.

webrtc/modules/audio_coding/neteq/timestamp_scaler_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.
  */
 
 #include "webrtc/modules/audio_coding/neteq/timestamp_scaler.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_decoder_database.h"
 #include "webrtc/modules/audio_coding/neteq/packet.h"
 
 using ::testing::Return;
 using ::testing::ReturnNull;
 using ::testing::_;
 
 namespace webrtc {
 
 TEST(TimestampScaler, TestNoScaling) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use PCMu, because it doesn't use scaled timestamps.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
   static const uint8_t kRtpPayloadType = 0;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   for (uint32_t timestamp = 0xFFFFFFFF - 5; timestamp != 5; ++timestamp) {
     // Scale to internal timestamp.
     EXPECT_EQ(timestamp, scaler.ToInternal(timestamp, kRtpPayloadType));
     // Scale back.
     EXPECT_EQ(timestamp, scaler.ToExternal(timestamp));
   }
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 TEST(TimestampScaler, TestNoScalingLargeStep) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use PCMu, because it doesn't use scaled timestamps.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderPCMu, factory);
   static const uint8_t kRtpPayloadType = 0;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   static const uint32_t kStep = 160;
   uint32_t start_timestamp = 0;
   // |external_timestamp| will be a large positive value.
   start_timestamp = start_timestamp - 5 * kStep;
   for (uint32_t timestamp = start_timestamp; timestamp != 5 * kStep;
       timestamp += kStep) {
     // Scale to internal timestamp.
     EXPECT_EQ(timestamp, scaler.ToInternal(timestamp, kRtpPayloadType));
     // Scale back.
     EXPECT_EQ(timestamp, scaler.ToExternal(timestamp));
   }
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 TEST(TimestampScaler, TestG722) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   uint32_t external_timestamp = 0xFFFFFFFF - 5;
   uint32_t internal_timestamp = external_timestamp;
   for (; external_timestamp != 5; ++external_timestamp) {
     // Scale to internal timestamp.
     EXPECT_EQ(internal_timestamp,
               scaler.ToInternal(external_timestamp, kRtpPayloadType));
     // Scale back.
     EXPECT_EQ(external_timestamp, scaler.ToExternal(internal_timestamp));
     internal_timestamp += 2;
   }
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 TEST(TimestampScaler, TestG722LargeStep) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   static const uint32_t kStep = 320;
   uint32_t external_timestamp = 0;
   // |external_timestamp| will be a large positive value.
   external_timestamp = external_timestamp - 5 * kStep;
   uint32_t internal_timestamp = external_timestamp;
   for (; external_timestamp != 5 * kStep; external_timestamp += kStep) {
     // Scale to internal timestamp.
     EXPECT_EQ(internal_timestamp,
               scaler.ToInternal(external_timestamp, kRtpPayloadType));
     // Scale back.
     EXPECT_EQ(external_timestamp, scaler.ToExternal(internal_timestamp));
     // Internal timestamp should be incremented with twice the step.
     internal_timestamp += 2 * kStep;
   }
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 TEST(TimestampScaler, TestG722WithCng) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info_g722(NetEqDecoder::kDecoderG722, "",
+  const DecoderDatabase::DecoderInfo info_g722(NetEqDecoder::kDecoderG722,
                                                factory);
-  const DecoderDatabase::DecoderInfo info_cng(NetEqDecoder::kDecoderCNGwb, "",
+  const DecoderDatabase::DecoderInfo info_cng(NetEqDecoder::kDecoderCNGwb,
                                               factory);
   static const uint8_t kRtpPayloadTypeG722 = 17;
   static const uint8_t kRtpPayloadTypeCng = 13;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadTypeG722))
       .WillRepeatedly(Return(&info_g722));
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadTypeCng))
       .WillRepeatedly(Return(&info_cng));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
@@ skipping 21 matching lines @@
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 // Make sure that the method ToInternal(Packet* packet) is wired up correctly.
 // Since it is simply calling the other ToInternal method, we are not doing
 // as many tests here.
 TEST(TimestampScaler, TestG722Packet) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   uint32_t external_timestamp = 0xFFFFFFFF - 5;
   uint32_t internal_timestamp = external_timestamp;
   Packet packet;
   packet.header.payloadType = kRtpPayloadType;
   for (; external_timestamp != 5; ++external_timestamp) {
     packet.header.timestamp = external_timestamp;
     // Scale to internal timestamp.
     scaler.ToInternal(&packet);
     EXPECT_EQ(internal_timestamp, packet.header.timestamp);
     internal_timestamp += 2;
   }
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 // Make sure that the method ToInternal(PacketList* packet_list) is wired up
 // correctly. Since it is simply calling the ToInternal(Packet* packet) method,
 // we are not doing as many tests here.
 TEST(TimestampScaler, TestG722PacketList) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   uint32_t external_timestamp = 0xFFFFFFFF - 5;
   uint32_t internal_timestamp = external_timestamp;
   Packet packet1;
   packet1.header.payloadType = kRtpPayloadType;
   packet1.header.timestamp = external_timestamp;
   Packet packet2;
   packet2.header.payloadType = kRtpPayloadType;
   packet2.header.timestamp = external_timestamp + 10;
   PacketList packet_list;
   packet_list.push_back(&packet1);
   packet_list.push_back(&packet2);
 
   scaler.ToInternal(&packet_list);
   EXPECT_EQ(internal_timestamp, packet1.header.timestamp);
   EXPECT_EQ(internal_timestamp + 20, packet2.header.timestamp);
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 TEST(TimestampScaler, TestG722Reset) {
   MockDecoderDatabase db;
   auto factory = CreateBuiltinAudioDecoderFactory();
   // Use G722, which has a factor 2 scaling.
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, "",
-                                          factory);
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderG722, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   uint32_t external_timestamp = 0xFFFFFFFF - 5;
   uint32_t internal_timestamp = external_timestamp;
   for (; external_timestamp != 5; ++external_timestamp) {
     // Scale to internal timestamp.
@@ skipping 18 matching lines @@
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 // TODO(minyue): This test becomes trivial since Opus does not need a timestamp
 // scaler. Therefore, this test may be removed in future. There is no harm to
 // keep it, since it can be taken as a test case for the situation of a trivial
 // timestamp scaler.
 TEST(TimestampScaler, TestOpusLargeStep) {
   MockDecoderDatabase db;
-  auto factory = CreateBuiltinAudioDecoderFactory();
-  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderOpus, "",
-                                          factory);
+  rtc::scoped_refptr<AudioDecoderFactory> factory =

[kwiberg-webrtc, 2016/09/20 16:05:43]

It'd be super handy if it was possible to write

  rtc::scoped_refptr<auto> factory = ...

and have the compiler infer the missing part(s) of they type, and complain if
the type wasn't of the correct form.

I guess fixing that will have to wait for a follow-up CL, though?

[ossu, 2016/09/21 09:10:56]

I should be able to put it just as
  auto factory = CreateBuiltinAudioDecoderFactory();
if we want a shorter line.

[kwiberg-webrtc, 2016/09/21 09:21:19]

Yes, but that's what you changed *from*, so I assumed that you wanted it to be
easier to see what type it was (and I agreed that it was useful). So by all
means, keep it like this. It's just a shame that there's almost no middle ground
between auto and the full type.

[ossu, 2016/09/21 15:46:30]

Ah, look at that! :) Well, I think that's probably just an oversight. Every
other factory in this file seems to be auto, so I'll just put it back to that.

+      CreateBuiltinAudioDecoderFactory();
+  const DecoderDatabase::DecoderInfo info(NetEqDecoder::kDecoderOpus, factory);
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
 
   TimestampScaler scaler(db);
   // Test both sides of the timestamp wrap-around.
   static const uint32_t kStep = 960;
   uint32_t external_timestamp = 0;
   // |external_timestamp| will be a large positive value.
   external_timestamp = external_timestamp - 5 * kStep;
@@ skipping 20 matching lines @@
   uint32_t timestamp = 4711;  // Some number.
   EXPECT_EQ(timestamp, scaler.ToInternal(timestamp, kRtpPayloadType));
 
   Packet* packet = NULL;
   scaler.ToInternal(packet);  // Should not crash. That's all we can test.
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
 }  // namespace webrtc