Change from WebRtcRTPHeader to RTPHeader in NetEq tests and tools

webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
 // Test to verify correct operation for externally created decoders.
 
 #include <memory>
 
 #include "webrtc/api/audio_codecs/builtin_audio_decoder_factory.h"
+#include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_generator.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 namespace webrtc {
 
@@ skipping 97 matching lines @@
       std::ostringstream ss;
       ss << "Lap number " << k << ".";
       SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
       // Compare mono and multi-channel.
       ASSERT_NO_FATAL_FAILURE(GetAndVerifyOutput());
 
       time_now += kOutputLengthMs;
     }
   }
 
-  void InsertPacket(WebRtcRTPHeader rtp_header,
+  void InsertPacket(RTPHeader rtp_header,
                     rtc::ArrayView<const uint8_t> payload,
                     uint32_t receive_timestamp) override {
-    EXPECT_CALL(
-        *external_decoder_,
-        IncomingPacket(_, payload.size(), rtp_header.header.sequenceNumber,
-                       rtp_header.header.timestamp, receive_timestamp));
+    EXPECT_CALL(*external_decoder_,
+                IncomingPacket(_, payload.size(), rtp_header.sequenceNumber,
+                               rtp_header.timestamp, receive_timestamp));
     NetEqExternalDecoderTest::InsertPacket(rtp_header, payload,
                                            receive_timestamp);
   }
 
   MockExternalPcm16B* external_decoder() { return external_decoder_.get(); }
 
   void ResetRtpGenerator(test::RtpGenerator* rtp_generator) {
     rtp_generator_.reset(rtp_generator);
   }
 
   int samples_per_ms() const { return samples_per_ms_; }
  private:
   std::unique_ptr<MockExternalPcm16B> external_decoder_;
   int samples_per_ms_;
   size_t frame_size_samples_;
   std::unique_ptr<test::RtpGenerator> rtp_generator_;
   int16_t* input_;
   uint8_t* encoded_;
   size_t payload_size_bytes_;
   uint32_t last_send_time_;
   uint32_t last_arrival_time_;
   std::unique_ptr<test::InputAudioFile> input_file_;
-  WebRtcRTPHeader rtp_header_;
+  RTPHeader rtp_header_;
 };
 
 // This test encodes a few packets of PCM16b 32 kHz data and inserts it into two
 // different NetEq instances. The first instance uses the internal version of
 // the decoder object, while the second one uses an externally created decoder
 // object (ExternalPcm16B wrapped in MockExternalPcm16B, both defined above).
 // The test verifies that the output from both instances match.
 class NetEqExternalVsInternalDecoderTest : public NetEqExternalDecoderUnitTest,
                                            public ::testing::Test {
  protected:
@@ skipping 26 matching lines @@
 
     // Get audio from external decoder instance.
     GetOutputAudio(&output_);
 
     for (size_t i = 0; i < output_.samples_per_channel_; ++i) {
       ASSERT_EQ(output_.data_[i], output_internal_.data_[i])
           << "Diff in sample " << i << ".";
     }
   }
 
-  void InsertPacket(WebRtcRTPHeader rtp_header,
+  void InsertPacket(RTPHeader rtp_header,
                     rtc::ArrayView<const uint8_t> payload,
                     uint32_t receive_timestamp) override {
     // Insert packet in internal decoder.
-    ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(
-                              rtp_header.header, payload, receive_timestamp));
+    ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(rtp_header, payload,
+                                                        receive_timestamp));
 
     // Insert packet in external decoder instance.
     NetEqExternalDecoderUnitTest::InsertPacket(rtp_header, payload,
                                                receive_timestamp);
   }
 
   int NumExpectedDecodeCalls(int num_loops) override { return num_loops; }
 
  private:
   int sample_rate_hz_;
@@ skipping 220 matching lines @@
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
 }  // namespace webrtc