Switch to standard integer types in content/renderer/.

content/renderer/pepper/ppb_video_decoder_impl.cc

 // Copyright (c) 2012 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/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 158 matching lines @@
 
 void PPB_VideoDecoder_Impl::AssignPictureBuffers(
     uint32_t no_of_buffers,
     const PP_PictureBuffer_Dev* buffers) {
   if (!decoder_)
     return;
   UMA_HISTOGRAM_COUNTS_100("Media.PepperVideoDecoderPictureCount",
                            no_of_buffers);
 
   std::vector<media::PictureBuffer> wrapped_buffers;
-  for (uint32 i = 0; i < no_of_buffers; i++) {
+  for (uint32_t i = 0; i < no_of_buffers; i++) {
     PP_PictureBuffer_Dev in_buf = buffers[i];
     DCHECK_GE(in_buf.id, 0);
     media::PictureBuffer buffer(
         in_buf.id,
         gfx::Size(in_buf.size.width, in_buf.size.height),
         in_buf.texture_id);
     wrapped_buffers.push_back(buffer);
     UMA_HISTOGRAM_COUNTS_10000("Media.PepperVideoDecoderPictureHeight",
                                in_buf.size.height);
   }
@@ skipping 37 matching lines @@
 void PPB_VideoDecoder_Impl::Destroy() {
   FlushCommandBuffer();
 
   decoder_.reset();
   ppp_videodecoder_ = NULL;
 
   ::ppapi::PPB_VideoDecoder_Shared::Destroy();
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
-    uint32 requested_num_of_buffers,
+    uint32_t requested_num_of_buffers,
     const gfx::Size& dimensions,
-    uint32 texture_target) {
+    uint32_t texture_target) {
   DCHECK(RenderThreadImpl::current());
   if (!GetPPP())
     return;
 
   PP_Size out_dim = PP_MakeSize(dimensions.width(), dimensions.height());
   GetPPP()->ProvidePictureBuffers(pp_instance(), pp_resource(),
                                   requested_num_of_buffers, &out_dim,
                                   texture_target);
 }
 
 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
   // So far picture.visible_rect is not used. If used, visible_rect should
   // be validated since it comes from GPU process and may not be trustworthy.
   DCHECK(RenderThreadImpl::current());
   if (!GetPPP())
     return;
 
   PP_Picture_Dev output;
   output.picture_buffer_id = picture.picture_buffer_id();
   output.bitstream_buffer_id = picture.bitstream_buffer_id();
   GetPPP()->PictureReady(pp_instance(), pp_resource(), &output);
 }
 
-void PPB_VideoDecoder_Impl::DismissPictureBuffer(int32 picture_buffer_id) {
+void PPB_VideoDecoder_Impl::DismissPictureBuffer(int32_t picture_buffer_id) {
   DCHECK(RenderThreadImpl::current());
   if (!GetPPP())
     return;
   GetPPP()->DismissPictureBuffer(pp_instance(), pp_resource(),
                                  picture_buffer_id);
 }
 
 void PPB_VideoDecoder_Impl::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   DCHECK(RenderThreadImpl::current());
   if (!GetPPP())
     return;
 
   PP_VideoDecodeError_Dev pp_error = MediaToPPError(error);
   GetPPP()->NotifyError(pp_instance(), pp_resource(), pp_error);
   UMA_HISTOGRAM_ENUMERATION("Media.PepperVideoDecoderError",
                             error,
                             media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
 }
 
 void PPB_VideoDecoder_Impl::NotifyResetDone() {
   DCHECK(RenderThreadImpl::current());
   RunResetCallback(PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
-    int32 bitstream_buffer_id) {
+    int32_t bitstream_buffer_id) {
   DCHECK(RenderThreadImpl::current());
   RunBitstreamBufferCallback(bitstream_buffer_id, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   DCHECK(RenderThreadImpl::current());
   RunFlushCallback(PP_OK);
 }
 
 }  // namespace content