Switch to standard integer types in media/.

media/video/gpu_memory_buffer_video_frame_pool.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 "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
@@ skipping 207 matching lines @@
     DCHECK_EQ(0u, plane);
     bytes_per_row += VideoFrame::RowBytes(1, format, width);
   }
   // Copy an even number of lines, and at least one.
   return std::max<size_t>((kBytesPerCopyTarget / bytes_per_row) & ~1, 1);
 }
 
 void CopyRowsToI420Buffer(int first_row,
                           int rows,
                           int bytes_per_row,
-                          const uint8* source,
+                          const uint8_t* source,
                           int source_stride,
-                          uint8* output,
+                          uint8_t* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToI420Buffer", "bytes_per_row", bytes_per_row,
                "rows", rows);
   if (output) {
     DCHECK_NE(dest_stride, 0);
     DCHECK_LE(bytes_per_row, std::abs(dest_stride));
     DCHECK_LE(bytes_per_row, source_stride);
 
     libyuv::CopyPlane(source + source_stride * first_row, source_stride,
                       output + dest_stride * first_row, dest_stride,
                       bytes_per_row, rows);
   }
   done.Run();
 }
 
 void CopyRowsToNV12Buffer(int first_row,
                           int rows,
                           int bytes_per_row,
                           const scoped_refptr<VideoFrame>& source_frame,
-                          uint8* dest_y,
+                          uint8_t* dest_y,
                           int dest_stride_y,
-                          uint8* dest_uv,
+                          uint8_t* dest_uv,
                           int dest_stride_uv,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToNV12Buffer", "bytes_per_row", bytes_per_row,
                "rows", rows);
   if (dest_y && dest_uv) {
     DCHECK_NE(dest_stride_y, 0);
     DCHECK_NE(dest_stride_uv, 0);
     DCHECK_LE(bytes_per_row, std::abs(dest_stride_y));
     DCHECK_LE(bytes_per_row, std::abs(dest_stride_uv));
     DCHECK_EQ(0, first_row % 2);
@@ skipping 12 matching lines @@
         dest_uv + first_row / 2 * dest_stride_uv, dest_stride_uv, bytes_per_row,
         rows);
   }
   done.Run();
 }
 
 void CopyRowsToUYVYBuffer(int first_row,
                           int rows,
                           int width,
                           const scoped_refptr<VideoFrame>& source_frame,
-                          uint8* output,
+                          uint8_t* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToUYVYBuffer", "bytes_per_row", width * 2,
                "rows", rows);
   if (output) {
     DCHECK_NE(dest_stride, 0);
     DCHECK_LE(width, std::abs(dest_stride / 2));
     DCHECK_EQ(0, first_row % 2);
     libyuv::I420ToUYVY(
         source_frame->visible_data(VideoFrame::kYPlane) +
@@ skipping 87 matching lines @@
   }
 
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PoolImpl::CopyVideoFrameToGpuMemoryBuffers, this,
                             video_frame, frame_resources, frame_ready_cb));
 }
 
 bool GpuMemoryBufferVideoFramePool::PoolImpl::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
-  const uint64 tracing_process_id =
+  const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
   const int kImportance = 2;
   for (const FrameResources* frame_resources : resources_pool_) {
     for (const PlaneResource& plane_resource :
          frame_resources->plane_resources) {
       if (plane_resource.gpu_memory_buffer) {
         gfx::GpuMemoryBufferId buffer_id =
             plane_resource.gpu_memory_buffer->GetId();
         std::string dump_name = base::StringPrintf(
@@ skipping 333 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media