Removed extended jitter report from RtcpSender

webrtc/modules/rtp_rtcp/source/rtcp_sender_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 254 matching lines @@
 
   int OnReceivedPayloadData(const uint8_t* payloadData,
                             const size_t payloadSize,
                             const WebRtcRTPHeader* rtpHeader) override {
     return 0;
   }
   RTCPReceiver* rtcp_receiver_;
   RTCPHelp::RTCPPacketInformation rtcp_packet_info_;
 };
 
+namespace {
+  static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
+  static const int kMaxPacketLength = 1500;
+  static const uint32_t kMainSsrc = 0x11111111;
+}
+
 class RtcpSenderTest : public ::testing::Test {
  protected:
-  static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
-
   RtcpSenderTest()
       : over_use_detector_options_(),
         clock_(1335900000),
         rtp_payload_registry_(new RTPPayloadRegistry(
             RTPPayloadStrategy::CreateStrategy(false))),
         remote_bitrate_observer_(),
         remote_bitrate_estimator_(
             RemoteBitrateEstimatorFactory().Create(
                 &remote_bitrate_observer_,
                 &clock_,
                 kMimdControl,
                 kRemoteBitrateEstimatorMinBitrateBps)),
         receive_statistics_(ReceiveStatistics::Create(&clock_)) {
     test_transport_ = new TestTransport();
 
     RtpRtcp::Configuration configuration;
     configuration.id = 0;
     configuration.audio = false;
     configuration.clock = &clock_;
     configuration.outgoing_transport = test_transport_;
     configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
 
     rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
     rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
-        0, &clock_, test_transport_, NULL, rtp_payload_registry_.get()));
+        configuration.id, &clock_, test_transport_, NULL,
+        rtp_payload_registry_.get()));
     rtcp_sender_ =
-        new RTCPSender(0, false, &clock_, receive_statistics_.get(), NULL);
+        new RTCPSender(configuration.id, false, &clock_,
+            receive_statistics_.get(), NULL);
+    rtcp_sender_->SetSSRC(kMainSsrc);
     rtcp_receiver_ =
-        new RTCPReceiver(0, &clock_, false, NULL, NULL, NULL, rtp_rtcp_impl_);
+        new RTCPReceiver(configuration.id, &clock_, false, NULL, NULL, NULL,
+            rtp_rtcp_impl_);
+    rtcp_receiver_->SetRemoteSSRC(kMainSsrc);
+
+    std::set<uint32_t> registered_ssrcs;
+    registered_ssrcs.insert(kMainSsrc);
+    rtcp_receiver_->SetSsrcs(kMainSsrc, registered_ssrcs);
     test_transport_->SetRTCPReceiver(rtcp_receiver_);
     // Initialize
     EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(test_transport_));
   }
+
   ~RtcpSenderTest() {
     delete rtcp_sender_;
     delete rtcp_receiver_;
     delete rtp_rtcp_impl_;
     delete test_transport_;
   }
 
   // Helper function: Incoming RTCP has a specific packet type.
   bool gotPacketType(RTCPPacketType packet_type) {
     return ((test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags) &
             packet_type) != 0U;
   }
 
   OverUseDetectorOptions over_use_detector_options_;
   SimulatedClock clock_;
   rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
   rtc::scoped_ptr<RtpReceiver> rtp_receiver_;
   ModuleRtpRtcpImpl* rtp_rtcp_impl_;
   RTCPSender* rtcp_sender_;
   RTCPReceiver* rtcp_receiver_;
   TestTransport* test_transport_;
   MockRemoteBitrateObserver remote_bitrate_observer_;
   rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
   rtc::scoped_ptr<ReceiveStatistics> receive_statistics_;
 
-  enum {kMaxPacketLength = 1500};
   uint8_t packet_[kMaxPacketLength];
 };
 
 TEST_F(RtcpSenderTest, RtcpOff) {
   rtcp_sender_->SetRTCPStatus(kRtcpOff);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
   EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
 }
 
-TEST_F(RtcpSenderTest, IJStatus) {
-  ASSERT_FALSE(rtcp_sender_->IJ());
-  rtcp_sender_->SetIJStatus(true);
-  EXPECT_TRUE(rtcp_sender_->IJ());
-}
-
 TEST_F(RtcpSenderTest, TestCompound) {
   const bool marker_bit = false;
   const uint8_t payload_type = 100;
   const uint16_t seq_num = 11111;
   const uint32_t timestamp = 1234567;
-  const uint32_t ssrc = 0x11111111;
   size_t packet_length = 0;
-  CreateRtpPacket(marker_bit, payload_type, seq_num, timestamp, ssrc, packet_,
-      &packet_length);
+  CreateRtpPacket(marker_bit, payload_type, seq_num, timestamp, kMainSsrc,
+                  packet_, &packet_length);
   EXPECT_EQ(25u, packet_length);
 
   VideoCodec codec_inst;
   strncpy(codec_inst.plName, "VP8", webrtc::kPayloadNameSize - 1);
   codec_inst.codecType = webrtc::kVideoCodecVP8;
   codec_inst.plType = payload_type;
   EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(codec_inst.plName,
                                                      codec_inst.plType,
                                                      90000,
                                                      0,
                                                      codec_inst.maxBitrate));
 
   // Make sure RTP packet has been received.
   rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
   RTPHeader header;
   EXPECT_TRUE(parser->Parse(packet_, packet_length, &header));
   PayloadUnion payload_specific;
   EXPECT_TRUE(rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
                                                         &payload_specific));
   receive_statistics_->IncomingPacket(header, packet_length, false);
   EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(header, packet_, packet_length,
                                                payload_specific, true));
 
-  rtcp_sender_->SetIJStatus(true);
+  rtcp_sender_->SetCNAME("Foo");
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr));
 
-  // Transmission time offset packet should be received.
+  // Sdes packet should be received, along with report blocks.
   ASSERT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags &
-      kRtcpTransmissionTimeOffset);
+              kRtcpSdes);
+  EXPECT_GT(test_transport_->rtcp_packet_info_.report_blocks.size(), 0u);
 }
 
 TEST_F(RtcpSenderTest, TestCompound_NoRtpReceived) {
-  rtcp_sender_->SetIJStatus(true);
+  rtcp_sender_->SetCNAME("Foo");
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr));
 
-  // Transmission time offset packet should not be received.
-  ASSERT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags &
-      kRtcpTransmissionTimeOffset);
+  // Sdes should be received, but no report blocks.
+  ASSERT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags &
+              kRtcpSdes);
+  EXPECT_EQ(0u, test_transport_->rtcp_packet_info_.report_blocks.size());
 }
 
 TEST_F(RtcpSenderTest, TestXrReceiverReferenceTime) {
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false));
   rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
 
   EXPECT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags &
@@ skipping 58 matching lines @@
 // to put an actual limit here. It's just information that no limit
 // is set, which is kind of the starting assumption.
 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one
 // situation where this caused confusion.
 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   TMMBRSet bounding_set;
   EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3));
   ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state,kRtcpSr));
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
   // We now expect the packet to show up in the rtcp_packet_info_ of
   // test_transport_.
   ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_TRUE(gotPacketType(kRtcpTmmbn));
   TMMBRSet* incoming_set = NULL;
   bool owner = false;
   // The BoundingSet function returns the number of members of the
   // bounding set, and touches the incoming set only if there's > 1.
   EXPECT_EQ(0, test_transport_->rtcp_receiver_->BoundingSet(owner,
       incoming_set));
@@ skipping 14 matching lines @@
   // test_transport_.
   ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_TRUE(gotPacketType(kRtcpTmmbn));
   TMMBRSet incoming_set;
   bool owner = false;
   // We expect 1 member of the incoming set.
   EXPECT_EQ(1, test_transport_->rtcp_receiver_->BoundingSet(owner,
       &incoming_set));
   EXPECT_EQ(kSourceSsrc, incoming_set.Ssrc(0));
 }
+
 }  // namespace webrtc