Switch to standard integer types in media/.

media/cast/logging/stats_event_subscriber.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 "media/cast/logging/stats_event_subscriber.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/format_macros.h"
@@ skipping 17 matching lines @@
 
 bool IsReceiverEvent(CastLoggingEvent event) {
   return event == FRAME_DECODED
       || event == FRAME_PLAYOUT
       || event == FRAME_ACK_SENT
       || event == PACKET_RECEIVED;
 }
 
 }  // namespace
 
-StatsEventSubscriber::SimpleHistogram::SimpleHistogram(int64 min,
-                                                       int64 max,
-                                                       int64 width)
+StatsEventSubscriber::SimpleHistogram::SimpleHistogram(int64_t min,
+                                                       int64_t max,
+                                                       int64_t width)
     : min_(min), max_(max), width_(width), buckets_((max - min) / width + 2) {
   CHECK_GT(buckets_.size(), 2u);
   CHECK_EQ(0, (max_ - min_) % width_);
 }
 
 StatsEventSubscriber::SimpleHistogram::~SimpleHistogram() {
 }
 
-void StatsEventSubscriber::SimpleHistogram::Add(int64 sample) {
+void StatsEventSubscriber::SimpleHistogram::Add(int64_t sample) {
   if (sample < min_) {
     ++buckets_.front();
   } else if (sample >= max_) {
     ++buckets_.back();
   } else {
     size_t index = 1 + (sample - min_) / width_;
     DCHECK_LT(index, buckets_.size());
     ++buckets_[index];
   }
 }
@@ skipping 11 matching lines @@
   if (buckets_.front()) {
     bucket->SetInteger(base::StringPrintf("<%" PRId64, min_),
                        buckets_.front());
     histo->Append(bucket.release());
   }
 
   for (size_t i = 1; i < buckets_.size() - 1; i++) {
     if (!buckets_[i])
       continue;
     bucket.reset(new base::DictionaryValue);
-    int64 lower = min_ + (i - 1) * width_;
-    int64 upper = lower + width_ - 1;
+    int64_t lower = min_ + (i - 1) * width_;
+    int64_t upper = lower + width_ - 1;
     bucket->SetInteger(
         base::StringPrintf("%" PRId64 "-%" PRId64, lower, upper),
         buckets_[i]);
     histo->Append(bucket.release());
   }
 
   if (buckets_.back()) {
     bucket.reset(new base::DictionaryValue);
     bucket->SetInteger(base::StringPrintf(">=%" PRId64, max_),
                        buckets_.back());
@@ skipping 496 matching lines @@
     base::TimeTicks receiver_time) {
   base::TimeDelta receiver_offset;
   if (!GetReceiverOffset(&receiver_offset))
     return;
   base::TimeTicks sender_time = receiver_time - receiver_offset;
   last_response_received_time_ = sender_time;
 }
 
 void StatsEventSubscriber::ErasePacketSentTime(
     const PacketEvent& packet_event) {
-  std::pair<RtpTimestamp, uint16> key(
+  std::pair<RtpTimestamp, uint16_t> key(
       std::make_pair(packet_event.rtp_timestamp, packet_event.packet_id));
   packet_sent_times_.erase(key);
 }
 
 void StatsEventSubscriber::RecordPacketRelatedLatencies(
     const PacketEvent& packet_event) {
   // Log queueing latency.
   if (packet_event.type == PACKET_SENT_TO_NETWORK) {
     FrameInfoMap::iterator it =
         recent_frame_infos_.find(packet_event.rtp_timestamp);
     if (it != recent_frame_infos_.end()) {
       base::TimeDelta latency =
           packet_event.timestamp - it->second.encode_end_time;
       total_queueing_latency_ += latency;
       queueing_latency_datapoints_++;
       histograms_[QUEUEING_LATENCY_MS_HISTO]->Add(
           latency.InMillisecondsF());
     }
   }
 
   // Log network latency and total packet latency;
   base::TimeDelta receiver_offset;
   if (!GetReceiverOffset(&receiver_offset))
     return;
 
-  std::pair<RtpTimestamp, uint16> key(
+  std::pair<RtpTimestamp, uint16_t> key(
       std::make_pair(packet_event.rtp_timestamp, packet_event.packet_id));
   PacketEventTimeMap::iterator it = packet_sent_times_.find(key);
   if (it == packet_sent_times_.end()) {
     std::pair<base::TimeTicks, CastLoggingEvent> value =
         std::make_pair(packet_event.timestamp, packet_event.type);
     packet_sent_times_.insert(std::make_pair(key, value));
     if (packet_sent_times_.size() > kMaxPacketEventTimeMapSize)
       packet_sent_times_.erase(packet_sent_times_.begin());
   } else {
     std::pair<base::TimeTicks, CastLoggingEvent> value = it->second;
@@ skipping 111 matching lines @@
     : event_counter(0), sum_size(0) {}
 StatsEventSubscriber::PacketLogStats::~PacketLogStats() {}
 
 StatsEventSubscriber::FrameInfo::FrameInfo() : encoded(false) {
 }
 StatsEventSubscriber::FrameInfo::~FrameInfo() {
 }
 
 }  // namespace cast
 }  // namespace media