Switch to standard integer types in media/.

media/renderers/skcanvas_video_renderer.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.
 
 #include "media/renderers/skcanvas_video_renderer.h"
 
 #include <limits>
 
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ skipping 252 matching lines @@
         } else {
           offset = (frame_->stride(VideoFrame::kUPlane) *
                     (frame_->visible_rect().y() >> y_shift)) +
                    (frame_->visible_rect().x() >> 1);
         }
 
         // Copy the frame to the supplied memory.
         // TODO: Find a way (API change?) to avoid this copy.
         char* out_line = static_cast<char*>(planes[plane]);
         int out_line_stride = row_bytes[plane];
-        uint8* in_line = frame_->data(plane) + offset;
+        uint8_t* in_line = frame_->data(plane) + offset;
         int in_line_stride = frame_->stride(plane);
         int plane_height = sizes[plane].height();
         if (in_line_stride == out_line_stride) {
           memcpy(out_line, in_line, plane_height * in_line_stride);
         } else {
           // Different line padding so need to copy one line at a time.
           int bytes_to_copy_per_line = out_line_stride < in_line_stride
                                            ? out_line_stride
                                            : in_line_stride;
           for (int line_no = 0; line_no < plane_height; line_no++) {
@@ skipping 20 matching lines @@
           this,
           &SkCanvasVideoRenderer::ResetCache) {}
 
 SkCanvasVideoRenderer::~SkCanvasVideoRenderer() {
   ResetCache();
 }
 
 void SkCanvasVideoRenderer::Paint(const scoped_refptr<VideoFrame>& video_frame,
                                   SkCanvas* canvas,
                                   const gfx::RectF& dest_rect,
-                                  uint8 alpha,
+                                  uint8_t alpha,
                                   SkXfermode::Mode mode,
                                   VideoRotation video_rotation,
                                   const Context3D& context_3d) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (alpha == 0) {
     return;
   }
 
   SkRect dest;
   dest.set(dest_rect.x(), dest_rect.y(), dest_rect.right(), dest_rect.bottom());
@@ skipping 141 matching lines @@
   switch (video_frame->format()) {
     case PIXEL_FORMAT_YV12:
     case PIXEL_FORMAT_I420:
       if (CheckColorSpace(video_frame, COLOR_SPACE_JPEG)) {
         LIBYUV_J420_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
                             video_frame->stride(VideoFrame::kYPlane),
                             video_frame->visible_data(VideoFrame::kUPlane),
                             video_frame->stride(VideoFrame::kUPlane),
                             video_frame->visible_data(VideoFrame::kVPlane),
                             video_frame->stride(VideoFrame::kVPlane),
-                            static_cast<uint8*>(rgb_pixels), row_bytes,
+                            static_cast<uint8_t*>(rgb_pixels), row_bytes,
                             video_frame->visible_rect().width(),
                             video_frame->visible_rect().height());
       } else if (CheckColorSpace(video_frame, COLOR_SPACE_HD_REC709)) {
         LIBYUV_H420_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
                             video_frame->stride(VideoFrame::kYPlane),
                             video_frame->visible_data(VideoFrame::kUPlane),
                             video_frame->stride(VideoFrame::kUPlane),
                             video_frame->visible_data(VideoFrame::kVPlane),
                             video_frame->stride(VideoFrame::kVPlane),
-                            static_cast<uint8*>(rgb_pixels), row_bytes,
+                            static_cast<uint8_t*>(rgb_pixels), row_bytes,
                             video_frame->visible_rect().width(),
                             video_frame->visible_rect().height());
       } else {
         LIBYUV_I420_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
                             video_frame->stride(VideoFrame::kYPlane),
                             video_frame->visible_data(VideoFrame::kUPlane),
                             video_frame->stride(VideoFrame::kUPlane),
                             video_frame->visible_data(VideoFrame::kVPlane),
                             video_frame->stride(VideoFrame::kVPlane),
-                            static_cast<uint8*>(rgb_pixels), row_bytes,
+                            static_cast<uint8_t*>(rgb_pixels), row_bytes,
                             video_frame->visible_rect().width(),
                             video_frame->visible_rect().height());
       }
       break;
     case PIXEL_FORMAT_YV16:
       LIBYUV_I422_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
                           video_frame->stride(VideoFrame::kYPlane),
                           video_frame->visible_data(VideoFrame::kUPlane),
                           video_frame->stride(VideoFrame::kUPlane),
                           video_frame->visible_data(VideoFrame::kVPlane),
                           video_frame->stride(VideoFrame::kVPlane),
-                          static_cast<uint8*>(rgb_pixels), row_bytes,
+                          static_cast<uint8_t*>(rgb_pixels), row_bytes,
                           video_frame->visible_rect().width(),
                           video_frame->visible_rect().height());
       break;
 
     case PIXEL_FORMAT_YV12A:
       LIBYUV_I420ALPHA_TO_ARGB(
           video_frame->visible_data(VideoFrame::kYPlane),
           video_frame->stride(VideoFrame::kYPlane),
           video_frame->visible_data(VideoFrame::kUPlane),
           video_frame->stride(VideoFrame::kUPlane),
           video_frame->visible_data(VideoFrame::kVPlane),
           video_frame->stride(VideoFrame::kVPlane),
           video_frame->visible_data(VideoFrame::kAPlane),
           video_frame->stride(VideoFrame::kAPlane),
-          static_cast<uint8*>(rgb_pixels), row_bytes,
+          static_cast<uint8_t*>(rgb_pixels), row_bytes,
           video_frame->visible_rect().width(),
           video_frame->visible_rect().height(),
           1);  // 1 = enable RGB premultiplication by Alpha.
       break;
 
     case PIXEL_FORMAT_YV24:
       LIBYUV_I444_TO_ARGB(video_frame->visible_data(VideoFrame::kYPlane),
                           video_frame->stride(VideoFrame::kYPlane),
                           video_frame->visible_data(VideoFrame::kUPlane),
                           video_frame->stride(VideoFrame::kUPlane),
                           video_frame->visible_data(VideoFrame::kVPlane),
                           video_frame->stride(VideoFrame::kVPlane),
-                          static_cast<uint8*>(rgb_pixels), row_bytes,
+                          static_cast<uint8_t*>(rgb_pixels), row_bytes,
                           video_frame->visible_rect().width(),
                           video_frame->visible_rect().height());
       break;
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_NV21:
     case PIXEL_FORMAT_UYVY:
     case PIXEL_FORMAT_YUY2:
     case PIXEL_FORMAT_ARGB:
     case PIXEL_FORMAT_XRGB:
     case PIXEL_FORMAT_RGB24:
@@ skipping 18 matching lines @@
   DCHECK(video_frame->HasTextures());
   DCHECK_EQ(1u, VideoFrame::NumPlanes(video_frame->format()));
 
   const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(0);
   DCHECK(mailbox_holder.texture_target == GL_TEXTURE_2D ||
          mailbox_holder.texture_target == GL_TEXTURE_RECTANGLE_ARB ||
          mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES)
       << mailbox_holder.texture_target;
 
   gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
-  uint32 source_texture = gl->CreateAndConsumeTextureCHROMIUM(
+  uint32_t source_texture = gl->CreateAndConsumeTextureCHROMIUM(
       mailbox_holder.texture_target, mailbox_holder.mailbox.name);
 
   // The video is stored in a unmultiplied format, so premultiply
   // if necessary.
   // Application itself needs to take care of setting the right |flip_y|
   // value down to get the expected result.
   // "flip_y == true" means to reverse the video orientation while
   // "flip_y == false" means to keep the intrinsic orientation.
   gl->CopyTextureCHROMIUM(GL_TEXTURE_2D, source_texture, texture,
                           internal_format, type, flip_y, premultiply_alpha,
                           false);
 
   gl->DeleteTextures(1, &source_texture);
   gl->Flush();
 
   SyncTokenClientImpl client(gl);
   video_frame->UpdateReleaseSyncToken(&client);
 }
 
 void SkCanvasVideoRenderer::ResetCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Clear cached values.
   last_image_ = nullptr;
   last_timestamp_ = kNoTimestamp();
 }
 
 }  // namespace media