Enable probing with repeated payload packets by default.

talk/media/base/videoengine_unittest.h

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 838 matching lines @@
     // EXPECT_EQ(0, info.receivers[0].packets_concealed);
     EXPECT_EQ(0, info.receivers[0].firs_sent);
     EXPECT_EQ(0, info.receivers[0].plis_sent);
     EXPECT_EQ(0, info.receivers[0].nacks_sent);
     EXPECT_EQ(DefaultCodec().width, info.receivers[0].frame_width);
     EXPECT_EQ(DefaultCodec().height, info.receivers[0].frame_height);
     EXPECT_GT(info.receivers[0].framerate_rcvd, 0);
     EXPECT_GT(info.receivers[0].framerate_decoded, 0);
     EXPECT_GT(info.receivers[0].framerate_output, 0);
   }
+
+  cricket::VideoSenderInfo GetSenderStats(size_t i) {
+    cricket::VideoMediaInfo info;
+    EXPECT_TRUE(channel_->GetStats(&info));
+    return info.senders[i];
+  }
+
+  cricket::VideoReceiverInfo GetReceiverStats(size_t i) {
+    cricket::VideoMediaInfo info;
+    EXPECT_TRUE(channel_->GetStats(&info));
+    return info.receivers[i];
+  }
+
   // Test that stats work properly for a conf call with multiple recv streams.
   void GetStatsMultipleRecvStreams() {
     cricket::FakeVideoRenderer renderer1, renderer2;
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(1)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
     EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer1.num_rendered_frames());
     EXPECT_EQ(0, renderer2.num_rendered_frames());
     std::vector<uint32> ssrcs;
     ssrcs.push_back(1);
     ssrcs.push_back(2);
     network_interface_.SetConferenceMode(true, ssrcs);
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
+
+    EXPECT_TRUE(channel_->SetSend(false));
+
     cricket::VideoMediaInfo info;
     EXPECT_TRUE(channel_->GetStats(&info));
-
     ASSERT_EQ(1U, info.senders.size());
     // TODO(whyuan): bytes_sent and bytes_rcvd are different. Are both payload?
     // For webrtc, bytes_sent does not include the RTP header length.
-    EXPECT_GT(info.senders[0].bytes_sent, 0);
-    EXPECT_EQ(NumRtpPackets(), info.senders[0].packets_sent);
-    EXPECT_EQ(DefaultCodec().width, info.senders[0].send_frame_width);
-    EXPECT_EQ(DefaultCodec().height, info.senders[0].send_frame_height);
+    EXPECT_GT(GetSenderStats(0).bytes_sent, 0);
+    EXPECT_EQ_WAIT(NumRtpPackets(), GetSenderStats(0).packets_sent, kTimeout);
+    EXPECT_EQ(DefaultCodec().width, GetSenderStats(0).send_frame_width);
+    EXPECT_EQ(DefaultCodec().height, GetSenderStats(0).send_frame_height);
 
     ASSERT_EQ(2U, info.receivers.size());
     for (size_t i = 0; i < info.receivers.size(); ++i) {
-      EXPECT_EQ(1U, info.receivers[i].ssrcs().size());
-      EXPECT_EQ(i + 1, info.receivers[i].ssrcs()[0]);
-      EXPECT_EQ(NumRtpBytes(), info.receivers[i].bytes_rcvd);
-      EXPECT_EQ(NumRtpPackets(), info.receivers[i].packets_rcvd);
-      EXPECT_EQ(DefaultCodec().width, info.receivers[i].frame_width);
-      EXPECT_EQ(DefaultCodec().height, info.receivers[i].frame_height);
+      EXPECT_EQ(1U, GetReceiverStats(i).ssrcs().size());
+      EXPECT_EQ(i + 1, GetReceiverStats(i).ssrcs()[0]);
+      EXPECT_EQ_WAIT(NumRtpBytes(), GetReceiverStats(i).bytes_rcvd, kTimeout);
+      EXPECT_EQ_WAIT(NumRtpPackets(), GetReceiverStats(i).packets_rcvd,
+                     kTimeout);
+      EXPECT_EQ(DefaultCodec().width, GetReceiverStats(i).frame_width);
+      EXPECT_EQ(DefaultCodec().height, GetReceiverStats(i).frame_height);
     }
   }
   // Test that stats work properly for a conf call with multiple send streams.
   void GetStatsMultipleSendStreams() {
     // Normal setup; note that we set the SSRC explicitly to ensure that
     // it will come first in the senders map.
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     EXPECT_TRUE(channel_->SetOptions(vmo));
@@ skipping 135 matching lines @@
   }
 
   // Tests setting up and configuring a send stream.
   void AddRemoveSendStreams() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
-    EXPECT_GE(2, NumRtpPackets());
+    EXPECT_GT(NumRtpPackets(), 0);
     uint32 ssrc = 0;
     size_t last_packet = NumRtpPackets() - 1;
     rtc::scoped_ptr<const rtc::Buffer>
         p(GetRtpPacket(static_cast<int>(last_packet)));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
 
     // Remove the send stream that was added during Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     int rtp_packets = NumRtpPackets();
@@ skipping 640 matching lines @@
 
   // Two streams one channel tests.
 
   // Tests that we can send and receive frames.
   void TwoStreamsSendAndReceive(const cricket::VideoCodec& codec) {
     SetUpSecondStream();
     // Test sending and receiving on first stream.
     SendAndReceive(codec);
     // Test sending and receiving on second stream.
     EXPECT_EQ_WAIT(1, renderer2_.num_rendered_frames(), kTimeout);
-    EXPECT_EQ(2, NumRtpPackets());
+    EXPECT_GT(NumRtpPackets(), 0);
     EXPECT_EQ(1, renderer2_.num_rendered_frames());
   }
 
   // Set up 2 streams where the first stream uses the default channel.
   // Then disconnect the first stream and verify default channel becomes
   // available.
   // Then add a new stream with |new_ssrc|. The new stream should re-use the
   // default channel.
   void TwoStreamsReUseFirstStream(const cricket::VideoCodec& codec) {
     SetUpSecondStream();
@@ skipping 149 matching lines @@
   rtc::scoped_ptr<C> channel_;
   cricket::FakeNetworkInterface network_interface_;
   cricket::FakeVideoRenderer renderer_;
   cricket::VideoMediaChannel::Error media_error_;
 
   // Used by test cases where 2 streams are run on the same channel.
   cricket::FakeVideoRenderer renderer2_;
 };
 
 #endif  // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_  NOLINT