Rewrote the PRNG using an xorshift* algorithm and moved the files from test/ to base/.

webrtc/call/rtc_event_log_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #ifdef ENABLE_RTC_EVENT_LOG
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/random.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/include/clock.h"
-#include "webrtc/test/random.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/call/rtc_event_log.pb.h"
 #else
 #include "webrtc/call/rtc_event_log.pb.h"
 #endif
@@ skipping 256 matching lines @@
 
 /*
  * Bit number i of extension_bitvector is set to indicate the
  * presence of extension number i from kExtensionTypes / kExtensionNames.
  * The least significant bit extension_bitvector has number 0.
  */
 size_t GenerateRtpPacket(uint32_t extensions_bitvector,
                          uint32_t csrcs_count,
                          uint8_t* packet,
                          size_t packet_size,
-                         test::Random* prng) {
+                         Random* prng) {
   RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions);
   Clock* clock = Clock::GetRealTimeClock();
 
   RTPSender rtp_sender(false,     // bool audio
                        clock,     // Clock* clock
                        nullptr,   // Transport*
                        nullptr,   // RtpAudioFeedback*
                        nullptr,   // PacedSender*
                        nullptr,   // PacketRouter*
                        nullptr,   // SendTimeObserver*
@@ skipping 27 matching lines @@
       packet, payload_type, marker_bit, capture_timestamp, capture_time_ms,
       timestamp_provided, inc_sequence_number);
 
   for (size_t i = header_size; i < packet_size; i++) {
     packet[i] = prng->Rand<uint8_t>();
   }
 
   return header_size;
 }
 
-rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket(test::Random* prng) {
+rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket(Random* prng) {
   rtcp::ReportBlock report_block;
   report_block.To(prng->Rand<uint32_t>());  // Remote SSRC.
   report_block.WithFractionLost(prng->Rand(50));
 
   rtcp::SenderReport sender_report;
   sender_report.From(prng->Rand<uint32_t>());  // Sender SSRC.
   sender_report.WithNtpSec(prng->Rand<uint32_t>());
   sender_report.WithNtpFrac(prng->Rand<uint32_t>());
   sender_report.WithPacketCount(prng->Rand<uint32_t>());
   sender_report.WithReportBlock(report_block);
 
   return sender_report.Build();
 }
 
 void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
                                 VideoReceiveStream::Config* config,
-                                test::Random* prng) {
+                                Random* prng) {
   // Create a map from a payload type to an encoder name.
   VideoReceiveStream::Decoder decoder;
   decoder.payload_type = prng->Rand(0, 127);
   decoder.payload_name = (prng->Rand<bool>() ? "VP8" : "H264");
   config->decoders.push_back(decoder);
   // Add SSRCs for the stream.
   config->rtp.remote_ssrc = prng->Rand<uint32_t>();
   config->rtp.local_ssrc = prng->Rand<uint32_t>();
   // Add extensions and settings for RTCP.
   config->rtp.rtcp_mode =
       prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize;
   config->rtp.remb = prng->Rand<bool>();
   // Add a map from a payload type to a new ssrc and a new payload type for RTX.
   VideoReceiveStream::Config::Rtp::Rtx rtx_pair;
   rtx_pair.ssrc = prng->Rand<uint32_t>();
   rtx_pair.payload_type = prng->Rand(0, 127);
   config->rtp.rtx.insert(std::make_pair(prng->Rand(0, 127), rtx_pair));
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       config->rtp.extensions.push_back(
           RtpExtension(kExtensionNames[i], prng->Rand<int>()));
     }
   }
 }
 
 void GenerateVideoSendConfig(uint32_t extensions_bitvector,
                              VideoSendStream::Config* config,
-                             test::Random* prng) {
+                             Random* prng) {
   // Create a map from a payload type to an encoder name.
   config->encoder_settings.payload_type = prng->Rand(0, 127);
   config->encoder_settings.payload_name = (prng->Rand<bool>() ? "VP8" : "H264");
   // Add SSRCs for the stream.
   config->rtp.ssrcs.push_back(prng->Rand<uint32_t>());
   // Add a map from a payload type to new ssrcs and a new payload type for RTX.
   config->rtp.rtx.ssrcs.push_back(prng->Rand<uint32_t>());
   config->rtp.rtx.payload_type = prng->Rand(0, 127);
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
@@ skipping 18 matching lines @@
   ASSERT_LE(bwe_loss_count, rtp_count);
   std::vector<rtc::Buffer> rtp_packets;
   std::vector<rtc::scoped_ptr<rtcp::RawPacket> > rtcp_packets;
   std::vector<size_t> rtp_header_sizes;
   std::vector<uint32_t> playout_ssrcs;
   std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
-  test::Random prng(random_seed);
+  Random prng(random_seed);
 
   // Create rtp_count RTP packets containing random data.
   for (size_t i = 0; i < rtp_count; i++) {
     size_t packet_size = prng.Rand(1000, 1100);
     rtp_packets.push_back(rtc::Buffer(packet_size));
     size_t header_size =
         GenerateRtpPacket(extensions_bitvector, csrcs_count,
                           rtp_packets[i].data(), packet_size, &prng);
     rtp_header_sizes.push_back(header_size);
   }
@@ skipping 136 matching lines @@
 
   // Try all combinations of header extensions and up to 2 CSRCS.
   for (extensions = 0; extensions < (1u << kNumExtensions); extensions++) {
     for (uint32_t csrcs_count = 0; csrcs_count < 3; csrcs_count++) {
       LogSessionAndReadBack(5 + extensions,   // Number of RTP packets.
                             2 + csrcs_count,  // Number of RTCP packets.
                             3 + csrcs_count,  // Number of playout events.
                             1 + csrcs_count,  // Number of BWE loss events.
                             extensions,       // Bit vector choosing extensions.
                             csrcs_count,      // Number of contributing sources.
-                            extensions + csrcs_count);  // Random seed.
+                            extensions * 3 + csrcs_count + 1);  // Random seed.
     }
   }
 }
 
 // Tests that the event queue works correctly, i.e. drops old RTP, RTCP and
 // debug events, but keeps config events even if they are older than the limit.
 void DropOldEvents(uint32_t extensions_bitvector,
                    uint32_t csrcs_count,
                    unsigned int random_seed) {
   rtc::Buffer old_rtp_packet;
   rtc::Buffer recent_rtp_packet;
   rtc::scoped_ptr<rtcp::RawPacket> old_rtcp_packet;
   rtc::scoped_ptr<rtcp::RawPacket> recent_rtcp_packet;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
-  test::Random prng(random_seed);
+  Random prng(random_seed);
 
   // Create two RTP packets containing random data.
   size_t packet_size = prng.Rand(1000, 1100);
   old_rtp_packet.SetSize(packet_size);
   GenerateRtpPacket(extensions_bitvector, csrcs_count, old_rtp_packet.data(),
                     packet_size, &prng);
   packet_size = prng.Rand(1000, 1100);
   recent_rtp_packet.SetSize(packet_size);
   size_t recent_header_size =
       GenerateRtpPacket(extensions_bitvector, csrcs_count,
@@ skipping 59 matching lines @@
   // Enable all header extensions
   uint32_t extensions = (1u << kNumExtensions) - 1;
   uint32_t csrcs_count = 2;
   DropOldEvents(extensions, csrcs_count, 141421356);
   DropOldEvents(extensions, csrcs_count, 173205080);
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG