Switch to standard integer types in content/renderer/.

content/renderer/pepper/pepper_video_encoder_host.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 "base/bind.h"
 #include "base/memory/shared_memory.h"
 #include "base/numerics/safe_math.h"
+#include "build/build_config.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/media/gpu_video_accelerator_util.h"
 #include "content/common/pepper_file_util.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_video_encoder_host.h"
 #include "content/renderer/pepper/video_encoder_shim.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 396 matching lines @@
     NotifyPepperError(PP_ERROR_NOMEMORY);
     return;
   }
 
   // If the plugin already requested video frames, we can now answer
   // that request.
   if (get_video_frames_reply_context_.is_valid())
     AllocateVideoFrames();
 }
 
-void PepperVideoEncoderHost::BitstreamBufferReady(int32 buffer_id,
+void PepperVideoEncoderHost::BitstreamBufferReady(int32_t buffer_id,
                                                   size_t payload_size,
                                                   bool key_frame) {
   DCHECK(RenderThreadImpl::current());
   DCHECK(shm_buffers_[buffer_id]->in_use);
 
   shm_buffers_[buffer_id]->in_use = false;
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoEncoder_BitstreamBufferReady(
           buffer_id, static_cast<uint32_t>(payload_size), key_frame));
@@ skipping 57 matching lines @@
   if (command_buffer_)
     return true;
 
   // There is no guarantee that we have a 3D context to work with. So
   // we create a dummy command buffer to communicate with the gpu process.
   channel_ = RenderThreadImpl::current()->EstablishGpuChannelSync(
       CAUSE_FOR_GPU_LAUNCH_PEPPERVIDEOENCODERACCELERATOR_INITIALIZE);
   if (!channel_)
     return false;
 
-  std::vector<int32> attribs(1, PP_GRAPHICS3DATTRIB_NONE);
+  std::vector<int32_t> attribs(1, PP_GRAPHICS3DATTRIB_NONE);
   command_buffer_ = channel_->CreateOffscreenCommandBuffer(
       gfx::Size(), nullptr, GpuChannelHost::kDefaultStreamId,
       GpuChannelHost::kDefaultStreamPriority, attribs, GURL::EmptyGURL(),
       gfx::PreferIntegratedGpu);
   if (!command_buffer_) {
     Close();
     return false;
   }
 
   command_buffer_->SetContextLostCallback(media::BindToCurrentLoop(
@@ skipping 103 matching lines @@
   get_video_frames_reply_context_ = ppapi::host::ReplyMessageContext();
 }
 
 scoped_refptr<media::VideoFrame> PepperVideoEncoderHost::CreateVideoFrame(
     uint32_t frame_id,
     const ppapi::host::ReplyMessageContext& reply_context) {
   DCHECK(RenderThreadImpl::current());
 
   ppapi::MediaStreamBuffer* buffer = buffer_manager_.GetBufferPointer(frame_id);
   DCHECK(buffer);
-  uint32_t shm_offset = static_cast<uint8*>(buffer->video.data) -
-                        static_cast<uint8*>(buffer_manager_.shm()->memory());
+  uint32_t shm_offset = static_cast<uint8_t*>(buffer->video.data) -
+                        static_cast<uint8_t*>(buffer_manager_.shm()->memory());
 
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalSharedMemory(
           media_input_format_, input_coded_size_, gfx::Rect(input_coded_size_),
-          input_coded_size_, static_cast<uint8*>(buffer->video.data),
+          input_coded_size_, static_cast<uint8_t*>(buffer->video.data),
           buffer->video.data_size, buffer_manager_.shm()->handle(), shm_offset,
           base::TimeDelta());
   frame->AddDestructionObserver(
       base::Bind(&PepperVideoEncoderHost::FrameReleased,
                  weak_ptr_factory_.GetWeakPtr(), reply_context, frame_id));
   return frame;
 }
 
 void PepperVideoEncoderHost::FrameReleased(
     const ppapi::host::ReplyMessageContext& reply_context,
     uint32_t frame_id) {
   DCHECK(RenderThreadImpl::current());
 
   ppapi::host::ReplyMessageContext context = reply_context;
   context.params.set_result(encoder_last_error_);
   host()->SendReply(context, PpapiPluginMsg_VideoEncoder_EncodeReply(frame_id));
 }
 
 void PepperVideoEncoderHost::NotifyPepperError(int32_t error) {
   DCHECK(RenderThreadImpl::current());
 
   encoder_last_error_ = error;
   Close();
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_VideoEncoder_NotifyError(encoder_last_error_));
 }
 
-uint8_t* PepperVideoEncoderHost::ShmHandleToAddress(int32 buffer_id) {
+uint8_t* PepperVideoEncoderHost::ShmHandleToAddress(int32_t buffer_id) {
   DCHECK(RenderThreadImpl::current());
   DCHECK_GE(buffer_id, 0);
-  DCHECK_LT(buffer_id, static_cast<int32>(shm_buffers_.size()));
+  DCHECK_LT(buffer_id, static_cast<int32_t>(shm_buffers_.size()));
   return static_cast<uint8_t*>(shm_buffers_[buffer_id]->shm->memory());
 }
 
 }  // namespace content