Delete class NullRtpData and function NullObjectRtpData

webrtc/modules/rtp_rtcp/source/rtp_receiver_unittest.cc

 /*
  *  Copyright (c) 2017 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 <memory>
 
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 
+using ::testing::NiceMock;
 using ::testing::UnorderedElementsAre;
 
 const uint32_t kTestRate = 64000u;
 const uint8_t kTestPayload[] = {'t', 'e', 's', 't'};
 const uint8_t kPcmuPayloadType = 96;
 const int64_t kGetSourcesTimeoutMs = 10000;
 const uint32_t kSsrc1 = 123;
 const uint32_t kSsrc2 = 124;
 const uint32_t kCsrc1 = 111;
 const uint32_t kCsrc2 = 222;
 const bool kInOrder = true;
 
 static uint32_t rtp_timestamp(int64_t time_ms) {
   return static_cast<uint32_t>(time_ms * kTestRate / 1000);
 }
 
 }  // namespace
 
 class RtpReceiverTest : public ::testing::Test {
  protected:
   RtpReceiverTest()
       : fake_clock_(123456),
         rtp_receiver_(
             RtpReceiver::CreateAudioReceiver(&fake_clock_,
-                                             nullptr,
+                                             &mock_rtp_data_,
                                              nullptr,
                                              &rtp_payload_registry_)) {
     CodecInst voice_codec = {};
     voice_codec.pltype = kPcmuPayloadType;
     voice_codec.plfreq = 8000;
     voice_codec.rate = kTestRate;
     memcpy(voice_codec.plname, "PCMU", 5);
     rtp_receiver_->RegisterReceivePayload(voice_codec);
   }
   ~RtpReceiverTest() {}
 
   bool FindSourceByIdAndType(const std::vector<RtpSource>& sources,
                              uint32_t source_id,
                              RtpSourceType type,
                              RtpSource* source) {
     for (size_t i = 0; i < sources.size(); ++i) {
       if (sources[i].source_id() == source_id &&
           sources[i].source_type() == type) {
         (*source) = sources[i];
         return true;
       }
     }
     return false;
   }
 
   SimulatedClock fake_clock_;
+  NiceMock<MockRtpData> mock_rtp_data_;
   RTPPayloadRegistry rtp_payload_registry_;
   std::unique_ptr<RtpReceiver> rtp_receiver_;
 };
 
 TEST_F(RtpReceiverTest, GetSources) {
   int64_t now_ms = fake_clock_.TimeInMilliseconds();
 
   RTPHeader header;
   header.payloadType = kPcmuPayloadType;
   header.ssrc = kSsrc1;
@@ skipping 160 matching lines @@
 
   auto csrc_sources = rtp_receiver_impl->csrc_sources_for_testing();
   ASSERT_EQ(1u, csrc_sources.size());
   EXPECT_EQ(kCsrc1, csrc_sources.begin()->source_id());
   EXPECT_EQ(RtpSourceType::CSRC, csrc_sources.begin()->source_type());
   EXPECT_EQ(fake_clock_.TimeInMilliseconds(),
             csrc_sources.begin()->timestamp_ms());
 }
 
 }  // namespace webrtc