Switch to standard integer types in content/renderer/.

content/renderer/media/video_capture_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.
 //
 // Notes about usage of this object by VideoCaptureImplManager.
 //
 // VideoCaptureImplManager access this object by using a Unretained()
 // binding and tasks on the IO thread. It is then important that
 // VideoCaptureImpl never post task to itself. All operations must be
 // synchronous.
 
 #include "content/renderer/media/video_capture_impl.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/common/media/video_capture_messages.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 
 namespace content {
@@ skipping 34 matching lines @@
     for (size_t i = 0; i < handles_.size(); ++i) {
       const size_t width = media::VideoFrame::Columns(i, format, size_.width());
       const size_t height = media::VideoFrame::Rows(i, format, size_.height());
       buffers_.push_back(GpuMemoryBufferImpl::CreateFromHandle(
           handles_[i], gfx::Size(width, height), gfx::BufferFormat::R_8,
           gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
           base::Bind(&ClientBuffer2::DestroyGpuMemoryBuffer,
                      base::Unretained(this))));
       bool rv = buffers_[i]->Map();
       DCHECK(rv);
-      data_[i] = reinterpret_cast<uint8*>(buffers_[i]->memory(0u));
+      data_[i] = reinterpret_cast<uint8_t*>(buffers_[i]->memory(0u));
       strides_[i] = width;
     }
   }
 
-  uint8* data(int plane) const { return data_[plane]; }
-  int32 stride(int plane) const { return strides_[plane]; }
+  uint8_t* data(int plane) const { return data_[plane]; }
+  int32_t stride(int plane) const { return strides_[plane]; }
   std::vector<gfx::GpuMemoryBufferHandle> gpu_memory_buffer_handles() {
     return handles_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<ClientBuffer2>;
 
   virtual ~ClientBuffer2() {
     for (auto& buffer : buffers_)
       buffer->Unmap();
   }
 
   void DestroyGpuMemoryBuffer(const gpu::SyncToken& sync_token) {}
 
   const std::vector<gfx::GpuMemoryBufferHandle> handles_;
   const gfx::Size size_;
   ScopedVector<gfx::GpuMemoryBuffer> buffers_;
-  uint8* data_[media::VideoFrame::kMaxPlanes];
-  int32 strides_[media::VideoFrame::kMaxPlanes];
+  uint8_t* data_[media::VideoFrame::kMaxPlanes];
+  int32_t strides_[media::VideoFrame::kMaxPlanes];
 
   DISALLOW_COPY_AND_ASSIGN(ClientBuffer2);
 };
 
 VideoCaptureImpl::ClientInfo::ClientInfo() {}
 VideoCaptureImpl::ClientInfo::~ClientInfo() {}
 
 VideoCaptureImpl::VideoCaptureImpl(
     const media::VideoCaptureSessionId session_id,
     VideoCaptureMessageFilter* filter)
@@ skipping 243 matching lines @@
       buffer_finished_callback = media::BindToCurrentLoop(
           base::Bind(&VideoCaptureImpl::OnClientBufferFinished2,
                      weak_factory_.GetWeakPtr(), buffer_id, buffer));
       break;
     }
     case media::VideoFrame::STORAGE_SHMEM: {
       const auto& iter = client_buffers_.find(buffer_id);
       DCHECK(iter != client_buffers_.end());
       const scoped_refptr<ClientBuffer> buffer = iter->second;
       frame = media::VideoFrame::WrapExternalSharedMemory(
-          pixel_format,
-          coded_size,
-          visible_rect,
-          gfx::Size(visible_rect.width(),
-                    visible_rect.height()),
-          reinterpret_cast<uint8*>(buffer->buffer()->memory()),
-          buffer->buffer_size(),
-          buffer->buffer()->handle(),
-          0 /* shared_memory_offset */,
-          timestamp - first_frame_timestamp_);
+          pixel_format, coded_size, visible_rect,
+          gfx::Size(visible_rect.width(), visible_rect.height()),
+          reinterpret_cast<uint8_t*>(buffer->buffer()->memory()),
+          buffer->buffer_size(), buffer->buffer()->handle(),
+          0 /* shared_memory_offset */, timestamp - first_frame_timestamp_);
       buffer_finished_callback = media::BindToCurrentLoop(
           base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
                      weak_factory_.GetWeakPtr(), buffer_id, buffer));
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   DCHECK(frame);
@@ skipping 80 matching lines @@
 }
 
 void VideoCaptureImpl::OnDeviceFormatsInUseReceived(
     const media::VideoCaptureFormats& formats_in_use) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   for (size_t i = 0; i < device_formats_in_use_cb_queue_.size(); ++i)
     device_formats_in_use_cb_queue_[i].Run(formats_in_use);
   device_formats_in_use_cb_queue_.clear();
 }
 
-void VideoCaptureImpl::OnDelegateAdded(int32 device_id) {
+void VideoCaptureImpl::OnDelegateAdded(int32_t device_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "OnDelegateAdded: device_id " << device_id;
 
   device_id_ = device_id;
   ClientInfoMap::iterator it = clients_pending_on_filter_.begin();
   while (it != clients_pending_on_filter_.end()) {
     const int client_id = it->first;
     const ClientInfo client_info = it->second;
     clients_pending_on_filter_.erase(it++);
     StartCapture(client_id, client_info.params, client_info.state_update_cb,
@@ skipping 68 matching lines @@
   double consumer_resource_utilization = -1.0;
   if (!metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                            &consumer_resource_utilization)) {
     consumer_resource_utilization = -1.0;
   }
 
   callback_to_io_thread.Run(*release_sync_token, consumer_resource_utilization);
 }
 
 }  // namespace content