Cast: Synthetic benchmark tool.

media/cast/test/utility/udp_proxy.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdlib.h>
+
 #include "media/cast/test/utility/udp_proxy.h"
 
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/rand_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 26 matching lines @@
 
 // Roughly emulates a buffer inside a device.
 // If the buffer is full, packets are dropped.
 // Packets are output at a maximum bandwidth.
 class Buffer : public PacketPipe {
  public:
   Buffer(size_t buffer_size, double max_megabits_per_second)
       : buffer_size_(0),
         max_buffer_size_(buffer_size),
         max_megabits_per_second_(max_megabits_per_second),
-        weak_factory_(this) {}
+        weak_factory_(this) {
+    CHECK_GT(max_buffer_size_, 0UL);
+    CHECK_GT(max_megabits_per_second, 0);
+  }
 
   virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
     if (packet->size() + buffer_size_ <= max_buffer_size_) {
       buffer_size_ += packet->size();
       buffer_.push_back(linked_ptr<transport::Packet>(packet.release()));
       if (buffer_.size() == 1) {
         Schedule();
       }
     }
   }
@@ skipping 26 matching lines @@
   double max_megabits_per_second_;  // megabits per second
   base::WeakPtrFactory<Buffer> weak_factory_;
 };
 
 scoped_ptr<PacketPipe> NewBuffer(size_t buffer_size, double bandwidth) {
   return scoped_ptr<PacketPipe>(new Buffer(buffer_size, bandwidth)).Pass();
 }
 
 class RandomDrop : public PacketPipe {
  public:
-  RandomDrop(double drop_fraction) : drop_fraction_(drop_fraction) {
-  }
+  RandomDrop(double drop_fraction)
+      : drop_fraction_(static_cast<int>(drop_fraction * RAND_MAX)) {}
 
   virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
-    if (base::RandDouble() >= drop_fraction_) {
+    if (rand() > drop_fraction_) {
       pipe_->Send(packet.Pass());
     }
   }
 
  private:
-  double drop_fraction_;
+  int drop_fraction_;
 };
 
 scoped_ptr<PacketPipe> NewRandomDrop(double drop_fraction) {
   return scoped_ptr<PacketPipe>(new RandomDrop(drop_fraction)).Pass();
 }
 
 class SimpleDelayBase : public PacketPipe {
  public:
   SimpleDelayBase() : weak_factory_(this) {}
   virtual ~SimpleDelayBase() {}
@@ skipping 460 matching lines @@
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media