[rtp_rtcp] lint errors about rand() usage fixed.

webrtc/modules/rtp_rtcp/source/rtp_fec_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.
  */
 
 #include <list>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/random.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 
 using webrtc::ForwardErrorCorrection;
 
 // Minimum RTP header size in bytes.
 const uint8_t kRtpHeaderSize = 12;
 
 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum.
 const uint8_t kTransportOverhead = 28;
@@ skipping 10 matching lines @@
   while (!my_list->empty()) {
     packet = my_list->front();
     delete packet;
     my_list->pop_front();
   }
 }
 
 class RtpFecTest : public ::testing::Test {
  protected:
   RtpFecTest()
-      : fec_(new ForwardErrorCorrection()), ssrc_(rand()), fec_seq_num_(0) {}
+      : random_(0xfec133700742),
+        fec_(new ForwardErrorCorrection()),
+        ssrc_(random_.Rand<uint32_t>()),
+        fec_seq_num_(0) {}
 
+  webrtc::Random random_;
   ForwardErrorCorrection* fec_;
   int ssrc_;
   uint16_t fec_seq_num_;
 
   PacketList media_packet_list_;
   PacketList fec_packet_list_;
   ReceivedPacketList received_packet_list_;
   RecoveredPacketList recovered_packet_list_;
 
   // Media packet "i" is lost if media_loss_mask_[i] = 1,
@@ skipping 828 matching lines @@
     // last media packet in frame.
     if (is_fec) seq_num++;
   }
 }
 
 int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets,
                                             int start_seq_num) {
   assert(num_media_packets > 0);
   ForwardErrorCorrection::Packet* media_packet = NULL;
   int sequence_number = start_seq_num;
-  int time_stamp = rand();
+  int time_stamp = random_.Rand<int>();
 
   for (int i = 0; i < num_media_packets; ++i) {
     media_packet = new ForwardErrorCorrection::Packet;
     media_packet_list_.push_back(media_packet);
-    media_packet->length = static_cast<size_t>(
-        (static_cast<float>(rand()) / RAND_MAX) *
-        (IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead -
-         ForwardErrorCorrection::PacketOverhead()));
+    const uint32_t kMinPacketSize = kRtpHeaderSize;
+    const uint32_t kMaxPacketSize = IP_PACKET_SIZE - kRtpHeaderSize -
+                                    kTransportOverhead -
+                                    ForwardErrorCorrection::PacketOverhead();
+    media_packet->length = random_.Rand(kMinPacketSize, kMaxPacketSize);
 
-    if (media_packet->length < kRtpHeaderSize) {
-      media_packet->length = kRtpHeaderSize;
-    }
     // Generate random values for the first 2 bytes
-    media_packet->data[0] = static_cast<uint8_t>(rand() % 256);
-    media_packet->data[1] = static_cast<uint8_t>(rand() % 256);
+    media_packet->data[0] = random_.Rand<uint8_t>();
+    media_packet->data[1] = random_.Rand<uint8_t>();
 
     // The first two bits are assumed to be 10 by the FEC encoder.
     // In fact the FEC decoder will set the two first bits to 10 regardless of
     // what they actually were. Set the first two bits to 10 so that a memcmp
     // can be performed for the whole restored packet.
     media_packet->data[0] |= 0x80;
     media_packet->data[0] &= 0xbf;
 
     // FEC is applied to a whole frame.
     // A frame is signaled by multiple packets without the marker bit set
     // followed by the last packet of the frame for which the marker bit is set.
     // Only push one (fake) frame to the FEC.
     media_packet->data[1] &= 0x7f;
 
     webrtc::ByteWriter<uint16_t>::WriteBigEndian(&media_packet->data[2],
                                                  sequence_number);
     webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[4],
                                                  time_stamp);
     webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8], ssrc_);
 
     // Generate random values for payload.
     for (size_t j = 12; j < media_packet->length; ++j) {
-      media_packet->data[j] = static_cast<uint8_t>(rand() % 256);
+      media_packet->data[j] = random_.Rand<uint8_t>();
     }
     sequence_number++;
   }
   // Last packet, set marker bit.
   assert(media_packet != NULL);
   media_packet->data[1] |= 0x80;
   return sequence_number;
 }
 
 int RtpFecTest::ConstructMediaPackets(int num_media_packets) {
-  return ConstructMediaPacketsSeqNum(num_media_packets, rand());
+  return ConstructMediaPacketsSeqNum(num_media_packets, random_.Rand<int>());
 }