Switch to standard integer types in media/.

media/cast/sender/vp8_encoder.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/vp8_encoder.h"
 
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 211 matching lines @@
       encoded_frame->dependency = EncodedFrame::DEPENDENT;
       // Frame dependencies could theoretically be relaxed by looking for the
       // VPX_FRAME_IS_DROPPABLE flag, but in recent testing (Oct 2014), this
       // flag never seems to be set.
       encoded_frame->referenced_frame_id = last_encoded_frame_id_ - 1;
     }
     encoded_frame->rtp_timestamp =
         TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency);
     encoded_frame->reference_time = reference_time;
     encoded_frame->data.assign(
-        static_cast<const uint8*>(pkt->data.frame.buf),
-        static_cast<const uint8*>(pkt->data.frame.buf) + pkt->data.frame.sz);
+        static_cast<const uint8_t*>(pkt->data.frame.buf),
+        static_cast<const uint8_t*>(pkt->data.frame.buf) + pkt->data.frame.sz);
     break;  // Done, since all data is provided in one CX_FRAME_PKT packet.
   }
   DCHECK(!encoded_frame->data.empty())
       << "BUG: Encoder must provide data since lagged encoding is disabled.";
 
   // TODO(miu): Determine when/why encoding can produce zero-length data,
   // which causes crypto crashes.  http://crbug.com/519022
   if (!has_seen_zero_length_encoded_frame_ && encoded_frame->data.empty()) {
     has_seen_zero_length_encoded_frame_ = true;
 
@@ skipping 40 matching lines @@
            << ", sized: " << encoded_frame->data.size()
            << ", deadline_utilization: " << encoded_frame->deadline_utilization
            << ", lossy_utilization: " << encoded_frame->lossy_utilization
            << " (quantizer chosen by the encoder was " << quantizer << ')';
 
   if (encoded_frame->dependency == EncodedFrame::KEY) {
     key_frame_requested_ = false;
   }
 }
 
-void Vp8Encoder::UpdateRates(uint32 new_bitrate) {
+void Vp8Encoder::UpdateRates(uint32_t new_bitrate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!is_initialized())
     return;
 
-  uint32 new_bitrate_kbit = new_bitrate / 1000;
+  uint32_t new_bitrate_kbit = new_bitrate / 1000;
   if (config_.rc_target_bitrate == new_bitrate_kbit)
     return;
 
   config_.rc_target_bitrate = bitrate_kbit_ = new_bitrate_kbit;
 
   // Update encoder context.
   if (vpx_codec_enc_config_set(&encoder_, &config_)) {
     NOTREACHED() << "Invalid return value";
   }
 
   VLOG(1) << "VP8 new rc_target_bitrate: " << new_bitrate_kbit << " kbps";
 }
 
 void Vp8Encoder::GenerateKeyFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_requested_ = true;
 }
 
 }  // namespace cast
 }  // namespace media