Use suffixed {uint,int}{8,16,32,64}_t types.

talk/media/base/videoframe_unittest.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 64 matching lines @@
   // Load a video frame from disk.
   bool LoadFrameNoRepeat(T* frame) {
     int save_repeat = repeat_;  // This LoadFrame disables repeat.
     repeat_ = 1;
     bool success = LoadFrame(kImageFilename, cricket::FOURCC_I420,
                             kWidth, kHeight, frame);
     repeat_ = save_repeat;
     return success;
   }
 
-  bool LoadFrame(const std::string& filename, uint32 format,
-                 int32 width, int32 height, T* frame) {
+  bool LoadFrame(const std::string& filename,
+                 uint32_t format,
+                 int32_t width,
+                 int32_t height,
+                 T* frame) {
     return LoadFrame(filename, format, width, height, width, abs(height),
                      webrtc::kVideoRotation_0, frame);
   }
   bool LoadFrame(const std::string& filename,
-                 uint32 format,
-                 int32 width,
-                 int32 height,
+                 uint32_t format,
+                 int32_t width,
+                 int32_t height,
                  int dw,
                  int dh,
                  webrtc::VideoRotation rotation,
                  T* frame) {
     rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(filename));
     return LoadFrame(ms.get(), format, width, height, dw, dh, rotation, frame);
   }
   // Load a video frame from a memory stream.
-  bool LoadFrame(rtc::MemoryStream* ms, uint32 format,
-                 int32 width, int32 height, T* frame) {
+  bool LoadFrame(rtc::MemoryStream* ms,
+                 uint32_t format,
+                 int32_t width,
+                 int32_t height,
+                 T* frame) {
     return LoadFrame(ms, format, width, height, width, abs(height),
                      webrtc::kVideoRotation_0, frame);
   }
   bool LoadFrame(rtc::MemoryStream* ms,
-                 uint32 format,
-                 int32 width,
-                 int32 height,
+                 uint32_t format,
+                 int32_t width,
+                 int32_t height,
                  int dw,
                  int dh,
                  webrtc::VideoRotation rotation,
                  T* frame) {
     if (!ms) {
       return false;
     }
     size_t data_size;
     bool ret = ms->GetSize(&data_size);
     EXPECT_TRUE(ret);
     if (ret) {
-      ret = LoadFrame(reinterpret_cast<uint8*>(ms->GetBuffer()), data_size,
+      ret = LoadFrame(reinterpret_cast<uint8_t*>(ms->GetBuffer()), data_size,
                       format, width, height, dw, dh, rotation, frame);
     }
     return ret;
   }
   // Load a frame from a raw buffer.
-  bool LoadFrame(uint8* sample, size_t sample_size, uint32 format,
-                 int32 width, int32 height, T* frame) {
+  bool LoadFrame(uint8_t* sample,
+                 size_t sample_size,
+                 uint32_t format,
+                 int32_t width,
+                 int32_t height,
+                 T* frame) {
     return LoadFrame(sample, sample_size, format, width, height, width,
                      abs(height), webrtc::kVideoRotation_0, frame);
   }
-  bool LoadFrame(uint8* sample,
+  bool LoadFrame(uint8_t* sample,
                  size_t sample_size,
-                 uint32 format,
-                 int32 width,
-                 int32 height,
+                 uint32_t format,
+                 int32_t width,
+                 int32_t height,
                  int dw,
                  int dh,
                  webrtc::VideoRotation rotation,
                  T* frame) {
     bool ret = false;
     for (int i = 0; i < repeat_; ++i) {
       ret = frame->Init(format, width, height, dw, dh,
                         sample, sample_size, 1, 1, 0, 0, rotation);
     }
     return ret;
@@ skipping 23 matching lines @@
   }
 
   // Write an I420 frame out to disk.
   bool DumpFrame(const std::string& prefix,
                  const cricket::VideoFrame& frame) {
     char filename[256];
     rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
                         prefix.c_str(), frame.GetWidth(), frame.GetHeight());
     size_t out_size = cricket::VideoFrame::SizeOf(frame.GetWidth(),
                                                   frame.GetHeight());
-    rtc::scoped_ptr<uint8[]> out(new uint8[out_size]);
+    rtc::scoped_ptr<uint8_t[]> out(new uint8_t[out_size]);
     frame.CopyToBuffer(out.get(), out_size);
     return DumpSample(filename, out.get(), out_size);
   }
 
   bool DumpSample(const std::string& filename, const void* buffer, int size) {
     rtc::Pathname path(filename);
     rtc::scoped_ptr<rtc::FileStream> fs(
         rtc::Filesystem::OpenFile(path, "wb"));
     if (!fs.get()) {
       return false;
     }
 
     return (fs->Write(buffer, size, NULL, NULL) == rtc::SR_SUCCESS);
   }
 
   // Create a test image in the desired color space.
   // The image is a checkerboard pattern with 63x63 squares, which allows
   // I420 chroma artifacts to easily be seen on the square boundaries.
   // The pattern is { { green, orange }, { blue, purple } }
   // There is also a gradient within each square to ensure that the luma
   // values are handled properly.
-  rtc::MemoryStream* CreateYuv422Sample(uint32 fourcc,
-                                              uint32 width, uint32 height) {
+  rtc::MemoryStream* CreateYuv422Sample(uint32_t fourcc,
+                                        uint32_t width,
+                                        uint32_t height) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
       return NULL;
     }
 
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     int awidth = (width + 1) & ~1;
     int size = awidth * 2 * height;
     if (!ms->ReserveSize(size)) {
       return NULL;
     }
-    for (uint32 y = 0; y < height; ++y) {
+    for (uint32_t y = 0; y < height; ++y) {
       for (int x = 0; x < awidth; x += 2) {
-        uint8 quad[4];
+        uint8_t quad[4];
         quad[y1_pos] = (x % 63 + y % 63) + 64;
         quad[y2_pos] = ((x + 1) % 63 + y % 63) + 64;
         quad[u_pos] = ((x / 63) & 1) ? 192 : 64;
         quad[v_pos] = ((y / 63) & 1) ? 192 : 64;
         ms->Write(quad, sizeof(quad), NULL, NULL);
       }
     }
     return ms.release();
   }
 
   // Create a test image for YUV 420 formats with 12 bits per pixel.
-  rtc::MemoryStream* CreateYuvSample(uint32 width, uint32 height,
-                                           uint32 bpp) {
+  rtc::MemoryStream* CreateYuvSample(uint32_t width,
+                                     uint32_t height,
+                                     uint32_t bpp) {
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bpp / 8)) {
       return NULL;
     }
 
-    for (uint32 i = 0; i < width * height * bpp / 8; ++i) {
+    for (uint32_t i = 0; i < width * height * bpp / 8; ++i) {
       char value = ((i / 63) & 1) ? 192 : 64;
       ms->Write(&value, sizeof(value), NULL, NULL);
     }
     return ms.release();
   }
 
-  rtc::MemoryStream* CreateRgbSample(uint32 fourcc,
-                                           uint32 width, uint32 height) {
+  rtc::MemoryStream* CreateRgbSample(uint32_t fourcc,
+                                     uint32_t width,
+                                     uint32_t height) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return NULL;
     }
 
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bytes)) {
       return NULL;
     }
 
-    for (uint32 y = 0; y < height; ++y) {
-      for (uint32 x = 0; x < width; ++x) {
-        uint8 rgb[4] = { 255, 255, 255, 255 };
+    for (uint32_t y = 0; y < height; ++y) {
+      for (uint32_t x = 0; x < width; ++x) {
+        uint8_t rgb[4] = {255, 255, 255, 255};
         rgb[r_pos] = ((x / 63) & 1) ? 224 : 32;
         rgb[g_pos] = (x % 63 + y % 63) + 96;
         rgb[b_pos] = ((y / 63) & 1) ? 224 : 32;
         ms->Write(rgb, bytes, NULL, NULL);
       }
     }
     return ms.release();
   }
 
   // Simple conversion routines to verify the optimized VideoFrame routines.
   // Converts from the specified colorspace to I420.
   bool ConvertYuv422(const rtc::MemoryStream* ms,
-                     uint32 fourcc, uint32 width, uint32 height,
+                     uint32_t fourcc,
+                     uint32_t width,
+                     uint32_t height,
                      T* frame) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
       return false;
     }
 
-    const uint8* start = reinterpret_cast<const uint8*>(ms->GetBuffer());
+    const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     int awidth = (width + 1) & ~1;
     frame->InitToBlack(width, height, 1, 1, 0, 0);
     int stride_y = frame->GetYPitch();
     int stride_u = frame->GetUPitch();
     int stride_v = frame->GetVPitch();
-    for (uint32 y = 0; y < height; ++y) {
-      for (uint32 x = 0; x < width; x += 2) {
-        const uint8* quad1 = start + (y * awidth + x) * 2;
+    for (uint32_t y = 0; y < height; ++y) {
+      for (uint32_t x = 0; x < width; x += 2) {
+        const uint8_t* quad1 = start + (y * awidth + x) * 2;
         frame->GetYPlane()[stride_y * y + x] = quad1[y1_pos];
         if ((x + 1) < width) {
           frame->GetYPlane()[stride_y * y + x + 1] = quad1[y2_pos];
         }
         if ((y & 1) == 0) {
-          const uint8* quad2 = quad1 + awidth * 2;
+          const uint8_t* quad2 = quad1 + awidth * 2;
           if ((y + 1) >= height) {
             quad2 = quad1;
           }
           frame->GetUPlane()[stride_u * (y / 2) + x / 2] =
               (quad1[u_pos] + quad2[u_pos] + 1) / 2;
           frame->GetVPlane()[stride_v * (y / 2) + x / 2] =
               (quad1[v_pos] + quad2[v_pos] + 1) / 2;
         }
       }
     }
     return true;
   }
 
   // Convert RGB to 420.
   // A negative height inverts the image.
   bool ConvertRgb(const rtc::MemoryStream* ms,
-                  uint32 fourcc, int32 width, int32 height,
+                  uint32_t fourcc,
+                  int32_t width,
+                  int32_t height,
                   T* frame) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return false;
     }
     int pitch = width * bytes;
-    const uint8* start = reinterpret_cast<const uint8*>(ms->GetBuffer());
+    const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     if (height < 0) {
       height = -height;
       start = start + pitch * (height - 1);
       pitch = -pitch;
     }
     frame->InitToBlack(width, height, 1, 1, 0, 0);
     int stride_y = frame->GetYPitch();
     int stride_u = frame->GetUPitch();
     int stride_v = frame->GetVPitch();
-    for (int32 y = 0; y < height; y += 2) {
-      for (int32 x = 0; x < width; x += 2) {
-        const uint8* rgb[4];
-        uint8 yuv[4][3];
+    for (int32_t y = 0; y < height; y += 2) {
+      for (int32_t x = 0; x < width; x += 2) {
+        const uint8_t* rgb[4];
+        uint8_t yuv[4][3];
         rgb[0] = start + y * pitch + x * bytes;
         rgb[1] = rgb[0] + ((x + 1) < width ? bytes : 0);
         rgb[2] = rgb[0] + ((y + 1) < height ? pitch : 0);
         rgb[3] = rgb[2] + ((x + 1) < width ? bytes : 0);
         for (size_t i = 0; i < 4; ++i) {
           ConvertRgbPixel(rgb[i][r_pos], rgb[i][g_pos], rgb[i][b_pos],
                           &yuv[i][0], &yuv[i][1], &yuv[i][2]);
         }
         frame->GetYPlane()[stride_y * y + x] = yuv[0][0];
         if ((x + 1) < width) {
           frame->GetYPlane()[stride_y * y + x + 1] = yuv[1][0];
         }
         if ((y + 1) < height) {
           frame->GetYPlane()[stride_y * (y + 1) + x] = yuv[2][0];
           if ((x + 1) < width) {
             frame->GetYPlane()[stride_y * (y + 1) + x + 1] = yuv[3][0];
           }
         }
         frame->GetUPlane()[stride_u * (y / 2) + x / 2] =
             (yuv[0][1] + yuv[1][1] + yuv[2][1] + yuv[3][1] + 2) / 4;
         frame->GetVPlane()[stride_v * (y / 2) + x / 2] =
             (yuv[0][2] + yuv[1][2] + yuv[2][2] + yuv[3][2] + 2) / 4;
       }
     }
     return true;
   }
 
   // Simple and slow RGB->YUV conversion. From NTSC standard, c/o Wikipedia.
-  void ConvertRgbPixel(uint8 r, uint8 g, uint8 b,
-                       uint8* y, uint8* u, uint8* v) {
+  void ConvertRgbPixel(uint8_t r,
+                       uint8_t g,
+                       uint8_t b,
+                       uint8_t* y,
+                       uint8_t* u,
+                       uint8_t* v) {
     *y = static_cast<int>(.257 * r + .504 * g + .098 * b) + 16;
     *u = static_cast<int>(-.148 * r - .291 * g + .439 * b) + 128;
     *v = static_cast<int>(.439 * r - .368 * g - .071 * b) + 128;
   }
 
-  bool GetYuv422Packing(uint32 fourcc,
-                        int* y1_pos, int* y2_pos, int* u_pos, int* v_pos) {
+  bool GetYuv422Packing(uint32_t fourcc,
+                        int* y1_pos,
+                        int* y2_pos,
+                        int* u_pos,
+                        int* v_pos) {
     if (fourcc == cricket::FOURCC_YUY2) {
       *y1_pos = 0; *u_pos = 1; *y2_pos = 2; *v_pos = 3;
     } else if (fourcc == cricket::FOURCC_UYVY) {
       *u_pos = 0; *y1_pos = 1; *v_pos = 2; *y2_pos = 3;
     } else {
       return false;
     }
     return true;
   }
 
-  bool GetRgbPacking(uint32 fourcc,
-                     int* r_pos, int* g_pos, int* b_pos, int* bytes) {
+  bool GetRgbPacking(uint32_t fourcc,
+                     int* r_pos,
+                     int* g_pos,
+                     int* b_pos,
+                     int* bytes) {
     if (fourcc == cricket::FOURCC_RAW) {
       *r_pos = 0; *g_pos = 1; *b_pos = 2; *bytes = 3;  // RGB in memory.
     } else if (fourcc == cricket::FOURCC_24BG) {
       *r_pos = 2; *g_pos = 1; *b_pos = 0; *bytes = 3;  // BGR in memory.
     } else if (fourcc == cricket::FOURCC_ABGR) {
       *r_pos = 0; *g_pos = 1; *b_pos = 2; *bytes = 4;  // RGBA in memory.
     } else if (fourcc == cricket::FOURCC_BGRA) {
       *r_pos = 1; *g_pos = 2; *b_pos = 3; *bytes = 4;  // ARGB in memory.
     } else if (fourcc == cricket::FOURCC_ARGB) {
       *r_pos = 2; *g_pos = 1; *b_pos = 0; *bytes = 4;  // BGRA in memory.
     } else {
       return false;
     }
     return true;
   }
 
   // Comparison functions for testing.
   static bool IsNull(const cricket::VideoFrame& frame) {
     return !frame.GetYPlane();
   }
 
   static bool IsSize(const cricket::VideoFrame& frame,
-                     uint32 width, uint32 height) {
-    return !IsNull(frame) &&
-        frame.GetYPitch() >= static_cast<int32>(width) &&
-        frame.GetUPitch() >= static_cast<int32>(width) / 2 &&
-        frame.GetVPitch() >= static_cast<int32>(width) / 2 &&
-        frame.GetWidth() == width && frame.GetHeight() == height;
+                     uint32_t width,
+                     uint32_t height) {
+    return !IsNull(frame) && frame.GetYPitch() >= static_cast<int32_t>(width) &&
+           frame.GetUPitch() >= static_cast<int32_t>(width) / 2 &&
+           frame.GetVPitch() >= static_cast<int32_t>(width) / 2 &&
+           frame.GetWidth() == width && frame.GetHeight() == height;
   }
 
   static bool IsPlaneEqual(const std::string& name,
-                           const uint8* plane1, uint32 pitch1,
-                           const uint8* plane2, uint32 pitch2,
-                           uint32 width, uint32 height,
+                           const uint8_t* plane1,
+                           uint32_t pitch1,
+                           const uint8_t* plane2,
+                           uint32_t pitch2,
+                           uint32_t width,
+                           uint32_t height,
                            int max_error) {
-    const uint8* r1 = plane1;
-    const uint8* r2 = plane2;
-    for (uint32 y = 0; y < height; ++y) {
-      for (uint32 x = 0; x < width; ++x) {
+    const uint8_t* r1 = plane1;
+    const uint8_t* r2 = plane2;
+    for (uint32_t y = 0; y < height; ++y) {
+      for (uint32_t x = 0; x < width; ++x) {
         if (abs(static_cast<int>(r1[x] - r2[x])) > max_error) {
           LOG(LS_INFO) << "IsPlaneEqual(" << name << "): pixel["
                        << x << "," << y << "] differs: "
                        << static_cast<int>(r1[x]) << " vs "
                        << static_cast<int>(r2[x]);
           return false;
         }
       }
       r1 += pitch1;
       r2 += pitch2;
     }
     return true;
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame,
-                      size_t width, size_t height,
-                      size_t pixel_width, size_t pixel_height,
-                      int64 elapsed_time, int64 time_stamp,
-                      const uint8* y, uint32 ypitch,
-                      const uint8* u, uint32 upitch,
-                      const uint8* v, uint32 vpitch,
+                      size_t width,
+                      size_t height,
+                      size_t pixel_width,
+                      size_t pixel_height,
+                      int64_t elapsed_time,
+                      int64_t time_stamp,
+                      const uint8_t* y,
+                      uint32_t ypitch,
+                      const uint8_t* u,
+                      uint32_t upitch,
+                      const uint8_t* v,
+                      uint32_t vpitch,
                       int max_error) {
-    return IsSize(frame,
-                  static_cast<uint32>(width),
-                  static_cast<uint32>(height)) &&
-        frame.GetPixelWidth() == pixel_width &&
-        frame.GetPixelHeight() == pixel_height &&
-        frame.GetElapsedTime() == elapsed_time &&
-        frame.GetTimeStamp() == time_stamp &&
-        IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
-                     static_cast<uint32>(width),
-                     static_cast<uint32>(height), max_error) &&
-        IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch,
-                     static_cast<uint32>((width + 1) / 2),
-                     static_cast<uint32>((height + 1) / 2), max_error) &&
-        IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch,
-                     static_cast<uint32>((width + 1) / 2),
-                     static_cast<uint32>((height + 1) / 2), max_error);
+    return IsSize(frame, static_cast<uint32_t>(width),
+                  static_cast<uint32_t>(height)) &&
+           frame.GetPixelWidth() == pixel_width &&
+           frame.GetPixelHeight() == pixel_height &&
+           frame.GetElapsedTime() == elapsed_time &&
+           frame.GetTimeStamp() == time_stamp &&
+           IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
+                        static_cast<uint32_t>(width),
+                        static_cast<uint32_t>(height), max_error) &&
+           IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch,
+                        static_cast<uint32_t>((width + 1) / 2),
+                        static_cast<uint32_t>((height + 1) / 2), max_error) &&
+           IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch,
+                        static_cast<uint32_t>((width + 1) / 2),
+                        static_cast<uint32_t>((height + 1) / 2), max_error);
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame1,
                       const cricket::VideoFrame& frame2,
                       int max_error) {
     return IsEqual(frame1,
                    frame2.GetWidth(), frame2.GetHeight(),
                    frame2.GetPixelWidth(), frame2.GetPixelHeight(),
                    frame2.GetElapsedTime(), frame2.GetTimeStamp(),
                    frame2.GetYPlane(), frame2.GetYPitch(),
@@ skipping 37 matching lines @@
 
   // Test constructing an image from a I420 buffer.
   void ConstructI420() {
     T frame;
     EXPECT_TRUE(IsNull(frame));
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
                           kWidth, kHeight, &frame));
 
-    const uint8* y = reinterpret_cast<uint8*>(ms.get()->GetBuffer());
-    const uint8* u = y + kWidth * kHeight;
-    const uint8* v = u + kWidth * kHeight / 4;
+    const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
+    const uint8_t* u = y + kWidth * kHeight;
+    const uint8_t* v = u + kWidth * kHeight / 4;
     EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0,
                         y, kWidth, u, kWidth / 2, v, kWidth / 2, 0));
   }
 
   // Test constructing an image from a YV12 buffer.
   void ConstructYV12() {
     T frame;
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YV12,
                           kWidth, kHeight, &frame));
 
-    const uint8* y = reinterpret_cast<uint8*>(ms.get()->GetBuffer());
-    const uint8* v = y + kWidth * kHeight;
-    const uint8* u = v + kWidth * kHeight / 4;
+    const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
+    const uint8_t* v = y + kWidth * kHeight;
+    const uint8_t* u = v + kWidth * kHeight / 4;
     EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0,
                         y, kWidth, u, kWidth / 2, v, kWidth / 2, 0));
   }
 
   // Test constructing an image from a I422 buffer.
   void ConstructI422() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]);
-    uint8* y = ALIGNP(buf.get(), kAlignment);
-    uint8* u = y + kWidth * kHeight;
-    uint8* v = u + (kWidth / 2) * kHeight;
+    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
+    uint8_t* y = ALIGNP(buf.get(), kAlignment);
+    uint8_t* u = y + kWidth * kHeight;
+    uint8_t* v = u + (kWidth / 2) * kHeight;
     EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
                                     frame1.GetVPlane(), frame1.GetVPitch(),
                                     y, kWidth,
                                     u, kWidth / 2,
                                     v, kWidth / 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(y, buf_size, cricket::FOURCC_I422,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 1));
   }
 
   // Test constructing an image from a YUY2 buffer.
   void ConstructYuy2() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]);
-    uint8* yuy2 = ALIGNP(buf.get(), kAlignment);
+    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
+    uint8_t* yuy2 = ALIGNP(buf.get(), kAlignment);
     EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
                                     frame1.GetVPlane(), frame1.GetVPitch(),
                                     yuy2, kWidth * 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
   }
 
   // Test constructing an image from a YUY2 buffer with buffer unaligned.
   void ConstructYuy2Unaligned() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment + 1]);
-    uint8* yuy2 = ALIGNP(buf.get(), kAlignment) + 1;
+    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment + 1]);
+    uint8_t* yuy2 = ALIGNP(buf.get(), kAlignment) + 1;
     EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
                                     frame1.GetVPlane(), frame1.GetVPitch(),
                                     yuy2, kWidth * 2,
                                     kWidth, kHeight));
     EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
   }
 
@@ skipping 135 matching lines @@
                            &frame1));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_RAW,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 2));
   }
 
   // Test constructing an image from a RGB565 buffer
   void ConstructRGB565() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
-    uint8* out = ALIGNP(outbuf.get(), kAlignment);
+    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_RGBP,
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_RGBP,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
   // Test constructing an image from a ARGB1555 buffer
   void ConstructARGB1555() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
-    uint8* out = ALIGNP(outbuf.get(), kAlignment);
+    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_RGBO,
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_RGBO,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
   // Test constructing an image from a ARGB4444 buffer
   void ConstructARGB4444() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
-    uint8* out = ALIGNP(outbuf.get(), kAlignment);
+    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_R444,
                                                  out,
                                                  out_size, kWidth * 2));
     EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_R444,
                           kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 20));
   }
 
 // Macro to help test different rotations
 #define TEST_MIRROR(FOURCC, BPP)                                               \
   void Construct##FOURCC##Mirror() {                                           \
     T frame1, frame2, frame3;                                                  \
     rtc::scoped_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth,          \
                           -kHeight, kWidth, kHeight,                           \
                           webrtc::kVideoRotation_180, &frame1));               \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
-                            reinterpret_cast<uint8*>(ms->GetBuffer()),         \
+                            reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
                             data_size, 1, 1, 0, 0, webrtc::kVideoRotation_0)); \
     int width_rotate = static_cast<int>(frame1.GetWidth());                    \
     int height_rotate = static_cast<int>(frame1.GetHeight());                  \
     EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 1, 1, 0, 0));  \
     libyuv::I420Mirror(                                                        \
         frame2.GetYPlane(), frame2.GetYPitch(), frame2.GetUPlane(),            \
         frame2.GetUPitch(), frame2.GetVPlane(), frame2.GetVPitch(),            \
         frame3.GetYPlane(), frame3.GetYPitch(), frame3.GetUPlane(),            \
         frame3.GetUPitch(), frame3.GetVPlane(), frame3.GetVPitch(), kWidth,    \
         kHeight);                                                              \
@@ skipping 10 matching lines @@
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth, kHeight, \
                           kWidth, kHeight, webrtc::kVideoRotation_##ROTATE,    \
                           &frame1));                                           \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
-                            reinterpret_cast<uint8*>(ms->GetBuffer()),         \
+                            reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
                             data_size, 1, 1, 0, 0, webrtc::kVideoRotation_0)); \
     int width_rotate = static_cast<int>(frame1.GetWidth());                    \
     int height_rotate = static_cast<int>(frame1.GetHeight());                  \
     EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 1, 1, 0, 0));  \
     libyuv::I420Rotate(                                                        \
         frame2.GetYPlane(), frame2.GetYPitch(), frame2.GetUPlane(),            \
         frame2.GetUPitch(), frame2.GetVPlane(), frame2.GetVPitch(),            \
         frame3.GetYPlane(), frame3.GetYPitch(), frame3.GetUPlane(),            \
         frame3.GetUPitch(), frame3.GetVPlane(), frame3.GetVPitch(), kWidth,    \
         kHeight, libyuv::kRotate##ROTATE);                                     \
@@ skipping 86 matching lines @@
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
                           kWidth, kHeight, webrtc::kVideoRotation_270,
                           &frame2));
   }
 
   // Test 1 pixel edge case image I420 buffer.
   void ConstructI4201Pixel() {
     T frame;
-    uint8 pixel[3] = { 1, 2, 3 };
+    uint8_t pixel[3] = {1, 2, 3};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, pixel,
                              sizeof(pixel), 1, 1, 0, 0,
                              webrtc::kVideoRotation_0));
     }
-    const uint8* y = pixel;
-    const uint8* u = y + 1;
-    const uint8* v = u + 1;
+    const uint8_t* y = pixel;
+    const uint8_t* u = y + 1;
+    const uint8_t* v = u + 1;
     EXPECT_TRUE(IsEqual(frame, 1, 1, 1, 1, 0, 0,
                         y, 1, u, 1, v, 1, 0));
   }
 
   // Test 5 pixel edge case image.
   void ConstructI4205Pixel() {
     T frame;
-    uint8 pixels5x5[5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) *  2];
+    uint8_t pixels5x5[5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) * 2];
     memset(pixels5x5, 1, 5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) *  2);
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 5, 5, 5, 5, pixels5x5,
                              sizeof(pixels5x5), 1, 1, 0, 0,
                              webrtc::kVideoRotation_0));
     }
     EXPECT_EQ(5u, frame.GetWidth());
     EXPECT_EQ(5u, frame.GetHeight());
     EXPECT_EQ(5, frame.GetYPitch());
     EXPECT_EQ(3, frame.GetUPitch());
     EXPECT_EQ(3, frame.GetVPitch());
   }
 
   // Test 1 pixel edge case image ARGB buffer.
   void ConstructARGB1Pixel() {
     T frame;
-    uint8 pixel[4] = { 64, 128, 192, 255 };
+    uint8_t pixel[4] = {64, 128, 192, 255};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 1, 1, 1, 1, pixel,
                              sizeof(pixel), 1, 1, 0, 0,
                              webrtc::kVideoRotation_0));
     }
     // Convert back to ARGB.
     size_t out_size = 4;
-    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
-    uint8* out = ALIGNP(outbuf.get(), kAlignment);
+    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
                                                  out,
                                                  out_size,    // buffer size
                                                  out_size));  // stride
   #ifdef USE_LMI_CONVERT
     // TODO(fbarchard): Expected to fail, but not crash.
     EXPECT_FALSE(IsPlaneEqual("argb", pixel, 4, out, 4, 3, 1, 2));
   #else
     // TODO(fbarchard): Check for overwrite.
     EXPECT_TRUE(IsPlaneEqual("argb", pixel, 4, out, 4, 3, 1, 2));
   #endif
   }
 
   // Test Black, White and Grey pixels.
   void ConstructARGBBlackWhitePixel() {
     T frame;
-    uint8 pixel[10 * 4] = { 0, 0, 0, 255,  // Black.
-                            0, 0, 0, 255,
-                            64, 64, 64, 255,  // Dark Grey.
-                            64, 64, 64, 255,
-                            128, 128, 128, 255,  // Grey.
-                            128, 128, 128, 255,
-                            196, 196, 196, 255,  // Light Grey.
-                            196, 196, 196, 255,
-                            255, 255, 255, 255,  // White.
-                            255, 255, 255, 255 };
+    uint8_t pixel[10 * 4] = {
+        0,   0,   0,   255,                      // Black.
+        0,   0,   0,   255, 64,  64,  64,  255,  // Dark Grey.
+        64,  64,  64,  255, 128, 128, 128, 255,  // Grey.
+        128, 128, 128, 255, 196, 196, 196, 255,  // Light Grey.
+        196, 196, 196, 255, 255, 255, 255, 255,  // White.
+        255, 255, 255, 255};
 
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 10, 1, 10, 1, pixel,
                              sizeof(pixel), 1, 1, 0, 0,
                              webrtc::kVideoRotation_0));
     }
     // Convert back to ARGB
     size_t out_size = 10 * 4;
-    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
-    uint8* out = ALIGNP(outbuf.get(), kAlignment);
+    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
+    uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
                                                  out,
                                                  out_size,    // buffer size.
                                                  out_size));  // stride.
     EXPECT_TRUE(IsPlaneEqual("argb", pixel, out_size,
                              out, out_size,
                              out_size, 1, 2));
   }
 
@@ skipping 101 matching lines @@
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     ASSERT_TRUE(LoadFrame(kJpeg400Filename,
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsPlaneEqual("y", frame1.GetYPlane(), frame1.GetYPitch(),
                              frame2.GetYPlane(), frame2.GetYPitch(),
                              kWidth, kHeight, 32));
     EXPECT_TRUE(IsEqual(frame1, frame2, 128));
   }
 
   // Test constructing an image from an I420 MJPG buffer.
-  void ValidateFrame(const char* name, uint32 fourcc, int data_adjust,
-                     int size_adjust, bool expected_result) {
+  void ValidateFrame(const char* name,
+                     uint32_t fourcc,
+                     int data_adjust,
+                     int size_adjust,
+                     bool expected_result) {
     T frame;
     rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(name));
     ASSERT_TRUE(ms.get() != NULL);
-    const uint8* sample = reinterpret_cast<const uint8*>(ms.get()->GetBuffer());
+    const uint8_t* sample =
+        reinterpret_cast<const uint8_t*>(ms.get()->GetBuffer());
     size_t sample_size;
     ms->GetSize(&sample_size);
     // Optional adjust size to test invalid size.
     size_t data_size = sample_size + data_adjust;
 
     // Allocate a buffer with end page aligned.
     const int kPadToHeapSized = 16 * 1024 * 1024;
-    rtc::scoped_ptr<uint8[]> page_buffer(
-        new uint8[((data_size + kPadToHeapSized + 4095) & ~4095)]);
-    uint8* data_ptr = page_buffer.get();
+    rtc::scoped_ptr<uint8_t[]> page_buffer(
+        new uint8_t[((data_size + kPadToHeapSized + 4095) & ~4095)]);
+    uint8_t* data_ptr = page_buffer.get();
     if (!data_ptr) {
       LOG(LS_WARNING) << "Failed to allocate memory for ValidateFrame test.";
       EXPECT_FALSE(expected_result);  // NULL is okay if failure was expected.
       return;
     }
     data_ptr += kPadToHeapSized + (-(static_cast<int>(data_size)) & 4095);
     memcpy(data_ptr, sample, std::min(data_size, sample_size));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(expected_result, frame.Validate(fourcc, kWidth, kHeight,
                                                 data_ptr,
@@ skipping 216 matching lines @@
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     size_t data_size;
     ms->GetSize(&data_size);
     EXPECT_TRUE(frame1.InitToBlack(kWidth, kHeight, 1, 1, 0, 0));
     EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 1, 1, 0, 0));
     EXPECT_TRUE(IsBlack(frame1));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_TRUE(frame1.Reset(cricket::FOURCC_I420, kWidth, kHeight, kWidth,
-                             kHeight, reinterpret_cast<uint8*>(ms->GetBuffer()),
-                             data_size, 1, 1, 0, 0, rotation,
-                             apply_rotation));
+                             kHeight,
+                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),
+                             data_size, 1, 1, 0, 0, rotation, apply_rotation));
     if (apply_rotation)
       EXPECT_EQ(webrtc::kVideoRotation_0, frame1.GetVideoRotation());
     else
       EXPECT_EQ(rotation, frame1.GetVideoRotation());
 
     // Swapp width and height if the frame is rotated 90 or 270 degrees.
     if (apply_rotation && (rotation == webrtc::kVideoRotation_90
         || rotation == webrtc::kVideoRotation_270)) {
       EXPECT_TRUE(kHeight == frame1.GetWidth());
       EXPECT_TRUE(kWidth == frame1.GetHeight());
@@ skipping 13 matching lines @@
     Reset(webrtc::kVideoRotation_90, false);
   }
 
   //////////////////////
   // Conversion tests //
   //////////////////////
 
   enum ToFrom { TO, FROM };
 
   // Helper function for test converting from I420 to packed formats.
-  inline void ConvertToBuffer(int bpp, int rowpad, bool invert, ToFrom to_from,
-      int error, uint32 fourcc,
-      int (*RGBToI420)(const uint8* src_frame, int src_stride_frame,
-                       uint8* dst_y, int dst_stride_y,
-                       uint8* dst_u, int dst_stride_u,
-                       uint8* dst_v, int dst_stride_v,
-                       int width, int height)) {
+  inline void ConvertToBuffer(int bpp,
+                              int rowpad,
+                              bool invert,
+                              ToFrom to_from,
+                              int error,
+                              uint32_t fourcc,
+                              int (*RGBToI420)(const uint8_t* src_frame,
+                                               int src_stride_frame,
+                                               uint8_t* dst_y,
+                                               int dst_stride_y,
+                                               uint8_t* dst_u,
+                                               int dst_stride_u,
+                                               uint8_t* dst_v,
+                                               int dst_stride_v,
+                                               int width,
+                                               int height)) {
     T frame1, frame2;
     int repeat_to = (to_from == TO) ? repeat_ : 1;
     int repeat_from  = (to_from == FROM) ? repeat_ : 1;
 
     int astride = kWidth * bpp + rowpad;
     size_t out_size = astride * kHeight;
-    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment + 1]);
+    rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment + 1]);
     memset(outbuf.get(), 0, out_size + kAlignment + 1);
-    uint8* outtop = ALIGNP(outbuf.get(), kAlignment);
-    uint8* out = outtop;
+    uint8_t* outtop = ALIGNP(outbuf.get(), kAlignment);
+    uint8_t* out = outtop;
     int stride = astride;
     if (invert) {
       out += (kHeight - 1) * stride;  // Point to last row.
       stride = -stride;
     }
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
 
     for (int i = 0; i < repeat_to; ++i) {
       EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(fourcc,
                                                     out,
@@ skipping 294 matching lines @@
   }
   void ConvertFromUYVYBufferInverted() {
     ConvertToBuffer(2, 0, true, FROM, kError,
                     cricket::FOURCC_UYVY, libyuv::UYVYToI420);
   }
 
   // Test converting from I420 to I422.
   void ConvertToI422Buffer() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    rtc::scoped_ptr<uint8[]> buf(new uint8[out_size + kAlignment]);
-    uint8* y = ALIGNP(buf.get(), kAlignment);
-    uint8* u = y + kWidth * kHeight;
-    uint8* v = u + (kWidth / 2) * kHeight;
+    rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[out_size + kAlignment]);
+    uint8_t* y = ALIGNP(buf.get(), kAlignment);
+    uint8_t* u = y + kWidth * kHeight;
+    uint8_t* v = u + (kWidth / 2) * kHeight;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(),
                                       frame1.GetUPlane(), frame1.GetUPitch(),
                                       frame1.GetVPlane(), frame1.GetVPitch(),
                                       y, kWidth,
                                       u, kWidth / 2,
                                       v, kWidth / 2,
                                       kWidth, kHeight));
     }
@@ skipping 42 matching lines @@
   }
 
   void CopyToBuffer() {
     T frame;
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight,
                           &frame));
     size_t out_size = kWidth * kHeight * 3 / 2;
-    rtc::scoped_ptr<uint8[]> out(new uint8[out_size]);
+    rtc::scoped_ptr<uint8_t[]> out(new uint8_t[out_size]);
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
     }
     EXPECT_EQ(0, memcmp(out.get(), ms->GetBuffer(), out_size));
   }
 
   void CopyToFrame() {
     T source;
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
@@ skipping 27 matching lines @@
       ms2.SetPosition(0u);  // Useful when repeat_ > 1.
       int error;
       EXPECT_EQ(rtc::SR_SUCCESS, frame.Write(&ms2, &error));
     }
     size_t out_size = cricket::VideoFrame::SizeOf(kWidth, kHeight);
     EXPECT_EQ(0, memcmp(ms2.GetBuffer(), ms->GetBuffer(), out_size));
   }
 
   void CopyToBuffer1Pixel() {
     size_t out_size = 3;
-    rtc::scoped_ptr<uint8[]> out(new uint8[out_size + 1]);
+    rtc::scoped_ptr<uint8_t[]> out(new uint8_t[out_size + 1]);
     memset(out.get(), 0xfb, out_size + 1);  // Fill buffer
-    uint8 pixel[3] = { 1, 2, 3 };
+    uint8_t pixel[3] = {1, 2, 3};
     T frame;
     EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, pixel,
                            sizeof(pixel), 1, 1, 0, 0,
                            webrtc::kVideoRotation_0));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
     }
     EXPECT_EQ(1, out.get()[0]);  // Check Y.  Should be 1.
     EXPECT_EQ(2, out.get()[1]);  // Check U.  Should be 2.
     EXPECT_EQ(3, out.get()[2]);  // Check V.  Should be 3.
@@ skipping 21 matching lines @@
     source.StretchToFrame(&target2, true, true);
     EXPECT_TRUE(IsBlack(target2));
     EXPECT_EQ(source.GetElapsedTime(), target2.GetElapsedTime());
     EXPECT_EQ(source.GetTimeStamp(), target2.GetTimeStamp());
   }
 
   int repeat_;
 };
 
 #endif  // TALK_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_