Switch to standard integer types in media/.

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 <math.h>
 #include <stdlib.h>
 #include <vector>
 
 #include "media/cast/test/utility/udp_proxy.h"
 
@@ skipping 54 matching lines @@
         Schedule();
       }
     }
   }
 
  private:
   void Schedule() {
     last_schedule_ = clock_->NowTicks();
     double megabits = buffer_.front()->size() * 8 / 1000000.0;
     double seconds = megabits / max_megabits_per_second_;
-    int64 microseconds = static_cast<int64>(seconds * 1E6);
+    int64_t microseconds = static_cast<int64_t>(seconds * 1E6);
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&Buffer::ProcessBuffer, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   void ProcessBuffer() {
-    int64 bytes_to_send = static_cast<int64>(
+    int64_t bytes_to_send = static_cast<int64_t>(
         (clock_->NowTicks() - last_schedule_).InSecondsF() *
         max_megabits_per_second_ * 1E6 / 8);
-    if (bytes_to_send < static_cast<int64>(buffer_.front()->size())) {
+    if (bytes_to_send < static_cast<int64_t>(buffer_.front()->size())) {
       bytes_to_send = buffer_.front()->size();
     }
     while (!buffer_.empty() &&
-           static_cast<int64>(buffer_.front()->size()) <= bytes_to_send) {
+           static_cast<int64_t>(buffer_.front()->size()) <= bytes_to_send) {
       CHECK(!buffer_.empty());
       scoped_ptr<Packet> packet(buffer_.front().release());
       bytes_to_send -= packet->size();
       buffer_size_ -= packet->size();
       buffer_.pop_front();
       pipe_->Send(packet.Pass());
     }
     if (!buffer_.empty()) {
       Schedule();
     }
@@ skipping 32 matching lines @@
 
 class SimpleDelayBase : public PacketPipe {
  public:
   SimpleDelayBase() : weak_factory_(this) {}
   ~SimpleDelayBase() override {}
 
   void Send(scoped_ptr<Packet> packet) override {
     double seconds = GetDelay();
     task_runner_->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&SimpleDelayBase::SendInternal,
-                   weak_factory_.GetWeakPtr(),
+        base::Bind(&SimpleDelayBase::SendInternal, weak_factory_.GetWeakPtr(),
                    base::Passed(&packet)),
-        base::TimeDelta::FromMicroseconds(static_cast<int64>(seconds * 1E6)));
+        base::TimeDelta::FromMicroseconds(static_cast<int64_t>(seconds * 1E6)));
   }
  protected:
   virtual double GetDelay() = 0;
 
  private:
   virtual void SendInternal(scoped_ptr<Packet> packet) {
     pipe_->Send(packet.Pass());
   }
 
   base::WeakPtrFactory<SimpleDelayBase> weak_factory_;
@@ skipping 75 matching lines @@
       base::TickClock* clock) final {
     PacketPipe::InitOnIOThread(task_runner, clock);
     // As we start the stream, assume that we are in a random
     // place between two extra delays, thus multiplier = 1.0;
     ScheduleExtraDelay(1.0);
   }
 
  private:
   void ScheduleExtraDelay(double mult) {
     double seconds = seconds_between_extra_delay_ * mult * base::RandDouble();
-    int64 microseconds = static_cast<int64>(seconds * 1E6);
+    int64_t microseconds = static_cast<int64_t>(seconds * 1E6);
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RandomSortedDelay::CauseExtraDelay,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   void CauseExtraDelay() {
     next_send_ = std::max<base::TimeTicks>(
-        clock_->NowTicks() +
-        base::TimeDelta::FromMicroseconds(
-            static_cast<int64>(extra_delay_ * 1E6)),
+        clock_->NowTicks() + base::TimeDelta::FromMicroseconds(
+                                 static_cast<int64_t>(extra_delay_ * 1E6)),
         next_send_);
     // An extra delay just happened, wait up to seconds_between_extra_delay_*2
     // before scheduling another one to make the average equal to
     // seconds_between_extra_delay_.
     ScheduleExtraDelay(2.0);
   }
 
   void ProcessBuffer() {
     base::TimeTicks now = clock_->NowTicks();
     while (!buffer_.empty() && next_send_ <= now) {
@@ skipping 52 matching lines @@
     if (works_) {
       pipe_->Send(packet.Pass());
     }
   }
 
  private:
   void Flip() {
     works_ = !works_;
     double seconds = base::RandDouble() *
         (works_ ? max_work_time_ : max_outage_time_);
-    int64 microseconds = static_cast<int64>(seconds * 1E6);
+    int64_t microseconds = static_cast<int64_t>(seconds * 1E6);
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&NetworkGlitchPipe::Flip, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   bool works_;
   double max_work_time_;
   double max_outage_time_;
   base::WeakPtrFactory<NetworkGlitchPipe> weak_factory_;
@@ skipping 70 matching lines @@
   base::TickClock* clock_;
   base::WeakPtrFactory<InternalBuffer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InternalBuffer);
 };
 
 InterruptedPoissonProcess::InterruptedPoissonProcess(
     const std::vector<double>& average_rates,
     double coef_burstiness,
     double coef_variance,
-    uint32 rand_seed)
+    uint32_t rand_seed)
     : clock_(NULL),
       average_rates_(average_rates),
       coef_burstiness_(coef_burstiness),
       coef_variance_(coef_variance),
       rate_index_(0),
       on_state_(true),
       weak_factory_(this) {
   mt_rand_.init_genrand(rand_seed);
   DCHECK(!average_rates.empty());
   ComputeRates();
@@ skipping 26 matching lines @@
   // Rate is per milliseconds.
   // The time until next event is exponentially distributed to the
   // inverse of |rate|.
   return base::TimeDelta::FromMillisecondsD(
       fabs(-log(1.0 - RandDouble()) / rate));
 }
 
 double InterruptedPoissonProcess::RandDouble() {
   // Generate a 64-bits random number from MT19937 and then convert
   // it to double.
-  uint64 rand = mt_rand_.genrand_int32();
+  uint64_t rand = mt_rand_.genrand_int32();
   rand <<= 32;
   rand |= mt_rand_.genrand_int32();
   return base::BitsToOpenEndedUnitInterval(rand);
 }
 
 void InterruptedPoissonProcess::ComputeRates() {
   double avg_rate = average_rates_[rate_index_];
 
   send_rate_ = avg_rate / coef_burstiness_;
   switch_off_rate_ =
@@ skipping 380 matching lines @@
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media