Switch to standard integer types in content/renderer/.

content/renderer/pepper/video_encoder_shim.cc

 // Copyright 2015 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 "content/renderer/pepper/video_encoder_shim.h"
 
 #include <inttypes.h>
 
 #include <deque>
 
@@ skipping 81 matching lines @@
 }  // namespace
 
 class VideoEncoderShim::EncoderImpl {
  public:
   explicit EncoderImpl(const base::WeakPtr<VideoEncoderShim>& shim);
   ~EncoderImpl();
 
   void Initialize(media::VideoPixelFormat input_format,
                   const gfx::Size& input_visible_size,
                   media::VideoCodecProfile output_profile,
-                  uint32 initial_bitrate);
+                  uint32_t initial_bitrate);
   void Encode(const scoped_refptr<media::VideoFrame>& frame,
               bool force_keyframe);
   void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer,
                                 uint8_t* mem);
-  void RequestEncodingParametersChange(uint32 bitrate, uint32 framerate);
+  void RequestEncodingParametersChange(uint32_t bitrate, uint32_t framerate);
   void Stop();
 
  private:
   struct PendingEncode {
     PendingEncode(const scoped_refptr<media::VideoFrame>& frame,
                   bool force_keyframe)
         : frame(frame), force_keyframe(force_keyframe) {}
     ~PendingEncode() {}
 
     scoped_refptr<media::VideoFrame> frame;
@@ skipping 14 matching lines @@
 
   base::WeakPtr<VideoEncoderShim> shim_;
   scoped_refptr<base::SingleThreadTaskRunner> renderer_task_runner_;
 
   bool initialized_;
 
   // Libvpx internal objects. Only valid if |initialized_| is true.
   vpx_codec_enc_cfg_t config_;
   vpx_codec_ctx_t encoder_;
 
-  uint32 framerate_;
+  uint32_t framerate_;
 
   std::deque<PendingEncode> frames_;
   std::deque<BitstreamBuffer> buffers_;
 };
 
 VideoEncoderShim::EncoderImpl::EncoderImpl(
     const base::WeakPtr<VideoEncoderShim>& shim)
     : shim_(shim),
       renderer_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       initialized_(false) {
 }
 
 VideoEncoderShim::EncoderImpl::~EncoderImpl() {
   if (initialized_)
     vpx_codec_destroy(&encoder_);
 }
 
 void VideoEncoderShim::EncoderImpl::Initialize(
     media::VideoPixelFormat input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
-    uint32 initial_bitrate) {
+    uint32_t initial_bitrate) {
   gfx::Size coded_size =
       media::VideoFrame::PlaneSize(input_format, 0, input_visible_size);
 
   vpx_codec_iface_t* vpx_codec;
   int32_t min_quantizer, max_quantizer, cpu_used;
   GetVpxCodecParameters(output_profile, &vpx_codec, &min_quantizer,
                         &max_quantizer, &cpu_used);
 
   // Populate encoder configuration with default values.
   if (vpx_codec_enc_config_default(vpx_codec, &config_, 0) != VPX_CODEC_OK) {
@@ skipping 70 matching lines @@
 }
 
 void VideoEncoderShim::EncoderImpl::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer,
     uint8_t* mem) {
   buffers_.push_back(BitstreamBuffer(buffer, mem));
   DoEncode();
 }
 
 void VideoEncoderShim::EncoderImpl::RequestEncodingParametersChange(
-    uint32 bitrate,
-    uint32 framerate) {
+    uint32_t bitrate,
+    uint32_t framerate) {
   framerate_ = framerate;
 
-  uint32 bitrate_kbit = bitrate / 1000;
+  uint32_t bitrate_kbit = bitrate / 1000;
   if (config_.rc_target_bitrate == bitrate_kbit)
     return;
 
   config_.rc_target_bitrate = bitrate_kbit;
   if (vpx_codec_enc_config_set(&encoder_, &config_) != VPX_CODEC_OK)
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
 }
 
 void VideoEncoderShim::EncoderImpl::Stop() {
   // Release frames on the renderer thread.
@@ skipping 126 matching lines @@
     profiles.push_back(profile);
   }
 
   return profiles;
 }
 
 bool VideoEncoderShim::Initialize(
     media::VideoPixelFormat input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
-    uint32 initial_bitrate,
+    uint32_t initial_bitrate,
     media::VideoEncodeAccelerator::Client* client) {
   DCHECK(RenderThreadImpl::current());
   DCHECK_EQ(client, host_);
 
   if (input_format != media::PIXEL_FORMAT_I420)
     return false;
 
   if (output_profile != media::VP8PROFILE_ANY &&
       output_profile != media::VP9PROFILE_ANY)
     return false;
@@ skipping 21 matching lines @@
     const media::BitstreamBuffer& buffer) {
   DCHECK(RenderThreadImpl::current());
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncoderShim::EncoderImpl::UseOutputBitstreamBuffer,
                  base::Unretained(encoder_impl_.get()), buffer,
                  host_->ShmHandleToAddress(buffer.id())));
 }
 
-void VideoEncoderShim::RequestEncodingParametersChange(uint32 bitrate,
-                                                       uint32 framerate) {
+void VideoEncoderShim::RequestEncodingParametersChange(uint32_t bitrate,
+                                                       uint32_t framerate) {
   DCHECK(RenderThreadImpl::current());
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &VideoEncoderShim::EncoderImpl::RequestEncodingParametersChange,
           base::Unretained(encoder_impl_.get()), bitrate, framerate));
 }
 
 void VideoEncoderShim::Destroy() {
   DCHECK(RenderThreadImpl::current());
 
   delete this;
 }
 
 void VideoEncoderShim::OnRequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) {
   DCHECK(RenderThreadImpl::current());
 
   host_->RequireBitstreamBuffers(input_count, input_coded_size,
                                  output_buffer_size);
 }
 
 void VideoEncoderShim::OnBitstreamBufferReady(
     scoped_refptr<media::VideoFrame> frame,
-    int32 bitstream_buffer_id,
+    int32_t bitstream_buffer_id,
     size_t payload_size,
     bool key_frame) {
   DCHECK(RenderThreadImpl::current());
 
   host_->BitstreamBufferReady(bitstream_buffer_id, payload_size, key_frame);
 }
 
 void VideoEncoderShim::OnNotifyError(
     media::VideoEncodeAccelerator::Error error) {
   DCHECK(RenderThreadImpl::current());
 
   host_->NotifyError(error);
 }
 
 }  // namespace content