Switch to standard integer types in media/.

media/cast/sender/video_sender.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/sender/video_sender.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 
@@ skipping 270 matching lines @@
 scoped_ptr<VideoFrameFactory> VideoSender::CreateVideoFrameFactory() {
   return video_encoder_ ? video_encoder_->CreateVideoFrameFactory() : nullptr;
 }
 
 int VideoSender::GetNumberOfFramesInEncoder() const {
   return frames_in_encoder_;
 }
 
 base::TimeDelta VideoSender::GetInFlightMediaDuration() const {
   if (GetUnacknowledgedFrameCount() > 0) {
-    const uint32 oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
+    const uint32_t oldest_unacked_frame_id = latest_acked_frame_id_ + 1;
     return last_enqueued_frame_reference_time_ -
         GetRecordedReferenceTime(oldest_unacked_frame_id);
   } else {
     return duration_in_encoder_;
   }
 }
 
 // static
 int VideoSender::GetMaximumTargetBitrateForFrame(
     const media::VideoFrame& frame) {
@@ skipping 19 matching lines @@
 
   // Determine the approximate height of a 16:9 frame having the same area
   // (number of pixels) as |frame|.
   const gfx::Size& resolution = frame.visible_rect().size();
   const int lines_of_resolution =
       ((resolution.width() * 9) == (resolution.height() * 16)) ?
           resolution.height() :
           static_cast<int>(sqrt(resolution.GetArea() * 9.0 / 16.0));
 
   // Linearly translate from |lines_of_resolution| to a maximum target bitrate.
-  int64 result = lines_of_resolution - STANDARD_RESOLUTION_LINES;
+  int64_t result = lines_of_resolution - STANDARD_RESOLUTION_LINES;
   result *= BITRATE_FOR_HIGH_RESOLUTION - BITRATE_FOR_STANDARD_RESOLUTION;
   result /= HIGH_RESOLUTION_LINES - STANDARD_RESOLUTION_LINES;
   result += BITRATE_FOR_STANDARD_RESOLUTION;
 
   // Boost the result for high frame rate content.
   base::TimeDelta frame_duration;
   if (frame.metadata()->GetTimeDelta(media::VideoFrameMetadata::FRAME_DURATION,
                                      &frame_duration) &&
       frame_duration > base::TimeDelta() &&
       frame_duration.InMicroseconds() <= HIGH_FRAME_RATE_THRESHOLD_USEC) {
@@ skipping 39 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media