Switch to standard integer types in content/renderer/.

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner_util.h"
 #include "content/renderer/media/webrtc/webrtc_video_frame_adapter.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/webrtc/base/bind.h"
 #include "third_party/webrtc/system_wrappers/include/ref_count.h"
 #include "third_party/webrtc/video_frame.h"
 
 namespace content {
 
-const int32 RTCVideoDecoder::ID_LAST = 0x3FFFFFFF;
-const int32 RTCVideoDecoder::ID_HALF = 0x20000000;
-const int32 RTCVideoDecoder::ID_INVALID = -1;
+const int32_t RTCVideoDecoder::ID_LAST = 0x3FFFFFFF;
+const int32_t RTCVideoDecoder::ID_HALF = 0x20000000;
+const int32_t RTCVideoDecoder::ID_INVALID = -1;
 
 // Maximum number of concurrent VDA::Decode() operations RVD will maintain.
 // Higher values allow better pipelining in the GPU, but also require more
 // resources.
 static const size_t kMaxInFlightDecodes = 8;
 
 // Number of allocated shared memory segments.
 static const size_t kNumSharedMemorySegments = 16;
 
 // Maximum number of pending WebRTC buffers that are waiting for shared memory.
 static const size_t kMaxNumOfPendingBuffers = 8;
 
-RTCVideoDecoder::BufferData::BufferData(int32 bitstream_buffer_id,
+RTCVideoDecoder::BufferData::BufferData(int32_t bitstream_buffer_id,
                                         uint32_t timestamp,
                                         size_t size,
                                         const gfx::Rect& visible_rect)
     : bitstream_buffer_id(bitstream_buffer_id),
       timestamp(timestamp),
       size(size),
       visible_rect(visible_rect) {}
 
 RTCVideoDecoder::BufferData::BufferData() {}
 
@@ skipping 226 matching lines @@
   if (state_ != RESETTING) {
     state_ = RESETTING;
     factories_->GetTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::ResetInternal,
                    weak_factory_.GetWeakPtr()));
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-void RTCVideoDecoder::ProvidePictureBuffers(uint32 count,
+void RTCVideoDecoder::ProvidePictureBuffers(uint32_t count,
                                             const gfx::Size& size,
-                                            uint32 texture_target) {
+                                            uint32_t texture_target) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DVLOG(3) << "ProvidePictureBuffers. texture_target=" << texture_target;
 
   if (!vda_)
     return;
 
-  std::vector<uint32> texture_ids;
+  std::vector<uint32_t> texture_ids;
   std::vector<gpu::Mailbox> texture_mailboxes;
   decoder_texture_target_ = texture_target;
   if (!factories_->CreateTextures(count,
                                   size,
                                   &texture_ids,
                                   &texture_mailboxes,
                                   decoder_texture_target_)) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   DCHECK_EQ(count, texture_ids.size());
   DCHECK_EQ(count, texture_mailboxes.size());
 
   std::vector<media::PictureBuffer> picture_buffers;
   for (size_t i = 0; i < texture_ids.size(); ++i) {
     picture_buffers.push_back(media::PictureBuffer(
         next_picture_buffer_id_++, size, texture_ids[i], texture_mailboxes[i]));
     bool inserted = assigned_picture_buffers_.insert(std::make_pair(
         picture_buffers.back().id(), picture_buffers.back())).second;
     DCHECK(inserted);
   }
   vda_->AssignPictureBuffers(picture_buffers);
 }
 
-void RTCVideoDecoder::DismissPictureBuffer(int32 id) {
+void RTCVideoDecoder::DismissPictureBuffer(int32_t id) {
   DVLOG(3) << "DismissPictureBuffer. id=" << id;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
-  std::map<int32, media::PictureBuffer>::iterator it =
+  std::map<int32_t, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(id);
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << id;
     return;
   }
 
   media::PictureBuffer buffer_to_dismiss = it->second;
   assigned_picture_buffers_.erase(it);
 
   if (!picture_buffers_at_display_.count(id)) {
     // We can delete the texture immediately as it's not being displayed.
     factories_->DeleteTexture(buffer_to_dismiss.texture_id());
     return;
   }
   // Not destroying a texture in display in |picture_buffers_at_display_|.
   // Postpone deletion until after it's returned to us.
 }
 
 void RTCVideoDecoder::PictureReady(const media::Picture& picture) {
   DVLOG(3) << "PictureReady";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
-  std::map<int32, media::PictureBuffer>::iterator it =
+  std::map<int32_t, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(picture.picture_buffer_id());
   if (it == assigned_picture_buffers_.end()) {
     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 
   uint32_t timestamp = 0;
   gfx::Rect visible_rect;
   GetBufferData(picture.bitstream_buffer_id(), &timestamp, &visible_rect);
@@ skipping 53 matching lines @@
           &RTCVideoDecoder::ReleaseMailbox, weak_factory_.GetWeakPtr(),
           factories_, picture.picture_buffer_id(), pb.texture_id())),
       pb.size(), visible_rect, visible_rect.size(), timestamp_ms));
   if (picture.allow_overlay()) {
     frame->metadata()->SetBoolean(media::VideoFrameMetadata::ALLOW_OVERLAY,
                                   true);
   }
   return frame;
 }
 
-void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
+void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32_t id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
-  std::map<int32, base::SharedMemory*>::iterator it =
+  std::map<int32_t, base::SharedMemory*>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   {
     base::AutoLock auto_lock(lock_);
     PutSHM_Locked(scoped_ptr<base::SharedMemory>(it->second));
@@ skipping 77 matching lines @@
                      << " existed already in bitstream_buffers_in_decoder_";
     RecordBufferData(buffer_data);
     vda_->Decode(bitstream_buffer);
   }
 }
 
 bool RTCVideoDecoder::CanMoreDecodeWorkBeDone() {
   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
 
-bool RTCVideoDecoder::IsBufferAfterReset(int32 id_buffer, int32 id_reset) {
+bool RTCVideoDecoder::IsBufferAfterReset(int32_t id_buffer, int32_t id_reset) {
   if (id_reset == ID_INVALID)
     return true;
-  int32 diff = id_buffer - id_reset;
+  int32_t diff = id_buffer - id_reset;
   if (diff <= 0)
     diff += ID_LAST + 1;
   return diff < ID_HALF;
 }
 
-bool RTCVideoDecoder::IsFirstBufferAfterReset(int32 id_buffer, int32 id_reset) {
+bool RTCVideoDecoder::IsFirstBufferAfterReset(int32_t id_buffer,
+                                              int32_t id_reset) {
   if (id_reset == ID_INVALID)
     return id_buffer == 0;
   return id_buffer == ((id_reset + 1) & ID_LAST);
 }
 
 void RTCVideoDecoder::SaveToDecodeBuffers_Locked(
     const webrtc::EncodedImage& input_image,
     scoped_ptr<base::SharedMemory> shm_buffer,
     const BufferData& buffer_data) {
   memcpy(shm_buffer->memory(), input_image._buffer, input_image._length);
@@ skipping 61 matching lines @@
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DVLOG(2) << "ResetInternal";
   if (vda_)
     vda_->Reset();
 }
 
 // static
 void RTCVideoDecoder::ReleaseMailbox(
     base::WeakPtr<RTCVideoDecoder> decoder,
     media::GpuVideoAcceleratorFactories* factories,
-    int64 picture_buffer_id,
-    uint32 texture_id,
+    int64_t picture_buffer_id,
+    uint32_t texture_id,
     const gpu::SyncToken& release_sync_token) {
   DCHECK(factories->GetTaskRunner()->BelongsToCurrentThread());
   factories->WaitSyncToken(release_sync_token);
 
   if (decoder) {
     decoder->ReusePictureBuffer(picture_buffer_id);
     return;
   }
   // It's the last chance to delete the texture after display,
   // because RTCVideoDecoder was destructed.
   factories->DeleteTexture(texture_id);
 }
 
-void RTCVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
+void RTCVideoDecoder::ReusePictureBuffer(int64_t picture_buffer_id) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DVLOG(3) << "ReusePictureBuffer. id=" << picture_buffer_id;
 
   DCHECK(!picture_buffers_at_display_.empty());
   PictureBufferTextureMap::iterator display_iterator =
       picture_buffers_at_display_.find(picture_buffer_id);
-  uint32 texture_id = display_iterator->second;
+  uint32_t texture_id = display_iterator->second;
   DCHECK(display_iterator != picture_buffers_at_display_.end());
   picture_buffers_at_display_.erase(display_iterator);
 
   if (!assigned_picture_buffers_.count(picture_buffer_id)) {
     // This picture was dismissed while in display, so we postponed deletion.
     factories_->DeleteTexture(texture_id);
     return;
   }
 
   // DestroyVDA() might already have been called.
@@ skipping 122 matching lines @@
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
   // using too-high a value is low (192 bits per extra slot).
   static const size_t kMaxInputBufferDataSize = 128;
   // Pop from the back of the list, because that's the oldest and least likely
   // to be useful in the future data.
   if (input_buffer_data_.size() > kMaxInputBufferDataSize)
     input_buffer_data_.pop_back();
 }
 
-void RTCVideoDecoder::GetBufferData(int32 bitstream_buffer_id,
+void RTCVideoDecoder::GetBufferData(int32_t bitstream_buffer_id,
                                     uint32_t* timestamp,
                                     gfx::Rect* visible_rect) {
   for (const auto& buffer_data : input_buffer_data_) {
     if (buffer_data.bitstream_buffer_id != bitstream_buffer_id)
       continue;
     *timestamp = buffer_data.timestamp;
     *visible_rect = buffer_data.visible_rect;
     return;
   }
   NOTREACHED() << "Missing bitstream buffer id: " << bitstream_buffer_id;
@@ skipping 13 matching lines @@
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
 }  // namespace content