Switch to standard integer types in content/renderer/.

content/renderer/pepper/pepper_video_decoder_host.cc

 // Copyright (c) 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 "content/renderer/pepper/pepper_video_decoder_host.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
+#include "build/build_config.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/pepper_file_util.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
 #include "content/renderer/pepper/video_decoder_shim.h"
 #include "media/base/limits.h"
@@ skipping 316 matching lines @@
   if (flush_reply_context_.is_valid() || reset_reply_context_.is_valid())
     return PP_ERROR_FAILED;
 
   reset_reply_context_ = context->MakeReplyMessageContext();
   decoder_->Reset();
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PepperVideoDecoderHost::ProvidePictureBuffers(
-    uint32 requested_num_of_buffers,
+    uint32_t requested_num_of_buffers,
     const gfx::Size& dimensions,
-    uint32 texture_target) {
+    uint32_t texture_target) {
   RequestTextures(std::max(min_picture_count_, requested_num_of_buffers),
                   dimensions,
                   texture_target,
                   std::vector<gpu::Mailbox>());
 }
 
 void PepperVideoDecoderHost::PictureReady(const media::Picture& picture) {
   PictureBufferMap::iterator it =
       picture_buffer_map_.find(picture.picture_buffer_id());
   DCHECK(it != picture_buffer_map_.end());
   DCHECK(it->second == PictureBufferState::ASSIGNED);
   it->second = PictureBufferState::IN_USE;
 
   // Don't bother validating the visible rect, since the plugin process is less
   // trusted than the gpu process.
   PP_Rect visible_rect = PP_FromGfxRect(picture.visible_rect());
   host()->SendUnsolicitedReply(pp_resource(),
                                PpapiPluginMsg_VideoDecoder_PictureReady(
                                    picture.bitstream_buffer_id(),
                                    picture.picture_buffer_id(), visible_rect));
 }
 
-void PepperVideoDecoderHost::DismissPictureBuffer(int32 picture_buffer_id) {
+void PepperVideoDecoderHost::DismissPictureBuffer(int32_t picture_buffer_id) {
   PictureBufferMap::iterator it = picture_buffer_map_.find(picture_buffer_id);
   DCHECK(it != picture_buffer_map_.end());
 
   // If the texture is still used by the plugin keep it until the plugin
   // recycles it.
   if (it->second == PictureBufferState::IN_USE) {
     it->second = PictureBufferState::DISMISSED;
     return;
   }
 
   DCHECK(it->second == PictureBufferState::ASSIGNED);
   picture_buffer_map_.erase(it);
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoDecoder_DismissPicture(picture_buffer_id));
 }
 
 void PepperVideoDecoderHost::NotifyEndOfBitstreamBuffer(
-    int32 bitstream_buffer_id) {
+    int32_t bitstream_buffer_id) {
   PendingDecodeList::iterator it = GetPendingDecodeById(bitstream_buffer_id);
   if (it == pending_decodes_.end()) {
     NOTREACHED();
     return;
   }
   host()->SendReply(it->reply_context,
                     PpapiPluginMsg_VideoDecoder_DecodeReply(it->shm_id));
   shm_buffer_busy_[it->shm_id] = false;
   pending_decodes_.erase(it);
 }
@@ skipping 41 matching lines @@
 }
 
 const uint8_t* PepperVideoDecoderHost::DecodeIdToAddress(uint32_t decode_id) {
   PendingDecodeList::const_iterator it = GetPendingDecodeById(decode_id);
   DCHECK(it != pending_decodes_.end());
   uint32_t shm_id = it->shm_id;
   return static_cast<uint8_t*>(shm_buffers_[shm_id]->memory());
 }
 
 void PepperVideoDecoderHost::RequestTextures(
-    uint32 requested_num_of_buffers,
+    uint32_t requested_num_of_buffers,
     const gfx::Size& dimensions,
-    uint32 texture_target,
+    uint32_t texture_target,
     const std::vector<gpu::Mailbox>& mailboxes) {
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoDecoder_RequestTextures(
           requested_num_of_buffers,
           PP_MakeSize(dimensions.width(), dimensions.height()),
           texture_target,
           mailboxes));
 }
 
@@ skipping 58 matching lines @@
 
 PepperVideoDecoderHost::PendingDecodeList::iterator
 PepperVideoDecoderHost::GetPendingDecodeById(int32_t decode_id) {
   return std::find_if(pending_decodes_.begin(), pending_decodes_.end(),
                       [decode_id](const PendingDecode& item) {
                         return item.decode_id == decode_id;
                       });
 }
 
 }  // namespace content