Switch to standard integer types in gpu/.

gpu/perftests/texture_upload_perftest.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 <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <vector>
 
 #include "base/containers/small_map.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/perftests/measurements.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 94 matching lines @@
       return GL_R8;
     default:
       NOTREACHED();
   }
   return 0;
 }
 
 void GenerateTextureData(const gfx::Size& size,
                          int bytes_per_pixel,
                          const int seed,
-                         std::vector<uint8>* const pixels) {
+                         std::vector<uint8_t>* const pixels) {
   // Row bytes has to be multiple of 4 (GL_PACK_ALIGNMENT defaults to 4).
   int stride = ((size.width() * bytes_per_pixel) + 3) & ~0x3;
   pixels->resize(size.height() * stride);
   for (int y = 0; y < size.height(); ++y) {
     for (int x = 0; x < size.width(); ++x) {
       for (int channel = 0; channel < bytes_per_pixel; ++channel) {
         int index = y * stride + x * bytes_per_pixel;
         pixels->at(index) = (index + (seed << 2)) % (0x20 << channel);
       }
     }
   }
 }
 
 // Compare a buffer containing pixels in a specified format to GL_RGBA buffer
 // where the former buffer have been uploaded as a texture and drawn on the
 // RGBA buffer.
 bool CompareBufferToRGBABuffer(GLenum format,
                                const gfx::Size& size,
-                               const std::vector<uint8>& pixels,
-                               const std::vector<uint8>& rgba) {
+                               const std::vector<uint8_t>& pixels,
+                               const std::vector<uint8_t>& rgba) {
   int bytes_per_pixel = GLFormatBytePerPixel(format);
   int pixels_stride = ((size.width() * bytes_per_pixel) + 3) & ~0x3;
   int rgba_stride = size.width() * GLFormatBytePerPixel(GL_RGBA);
   for (int y = 0; y < size.height(); ++y) {
     for (int x = 0; x < size.width(); ++x) {
       int rgba_index = y * rgba_stride + x * GLFormatBytePerPixel(GL_RGBA);
       int pixels_index = y * pixels_stride + x * bytes_per_pixel;
-      uint8 expected[4] = {0};
+      uint8_t expected[4] = {0};
       switch (format) {
         case GL_LUMINANCE:  // (L_t, L_t, L_t, 1)
           expected[1] = pixels[pixels_index];
           expected[2] = pixels[pixels_index];
         case GL_RED:  // (R_t, 0, 0, 1)
           expected[0] = pixels[pixels_index];
           expected[3] = 255;
           break;
         case GL_RGBA:  // (R_t, G_t, B_t, A_t)
           memcpy(expected, &pixels[pixels_index], 4);
@@ skipping 165 matching lines @@
                      size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE,
                      nullptr);
         CheckNoGlError("glTexImage2D");
       }
     }
     return texture_id;
   }
 
   void UploadTexture(GLuint texture_id,
                      const gfx::Size& size,
-                     const std::vector<uint8>& pixels,
+                     const std::vector<uint8_t>& pixels,
                      GLenum format,
                      const bool subimage) {
     if (subimage) {
       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size.width(), size.height(),
                       format, GL_UNSIGNED_BYTE, &pixels[0]);
       CheckNoGlError("glTexSubImage2D");
     } else {
       glTexImage2D(GL_TEXTURE_2D, 0, GLFormatToInternalFormat(format),
                    size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE,
                    &pixels[0]);
       CheckNoGlError("glTexImage2D");
     }
   }
 
   // Upload and draw on the offscren surface.
   // Return a list of pair. Each pair describe a gl operation and the wall
   // time elapsed in milliseconds.
   std::vector<Measurement> UploadAndDraw(GLuint texture_id,
                                          const gfx::Size& size,
-                                         const std::vector<uint8>& pixels,
+                                         const std::vector<uint8_t>& pixels,
                                          const GLenum format,
                                          const bool subimage) {
     MeasurementTimers tex_timers(gpu_timing_client_.get());
     UploadTexture(texture_id, size, pixels, format, subimage);
     tex_timers.Record();
 
     MeasurementTimers first_draw_timers(gpu_timing_client_.get());
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     first_draw_timers.Record();
 
     MeasurementTimers draw_timers(gpu_timing_client_.get());
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     draw_timers.Record();
 
     MeasurementTimers finish_timers(gpu_timing_client_.get());
     glFinish();
     CheckNoGlError("glFinish");
     finish_timers.Record();
 
-    std::vector<uint8> pixels_rendered(size.GetArea() * 4);
+    std::vector<uint8_t> pixels_rendered(size.GetArea() * 4);
     glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError("glReadPixels");
     EXPECT_TRUE(
         CompareBufferToRGBABuffer(format, size, pixels, pixels_rendered))
         << "Format is: " << gfx::GLEnums::GetStringEnum(format);
 
     std::vector<Measurement> measurements;
     bool gpu_timer_errors =
         gpu_timing_client_->IsAvailable() &&
         gpu_timing_client_->CheckAndResetTimerErrors();
     if (!gpu_timer_errors) {
       measurements.push_back(tex_timers.GetAsMeasurement(
           subimage ? "texsubimage2d" : "teximage2d"));
       measurements.push_back(
           first_draw_timers.GetAsMeasurement("firstdrawarrays"));
       measurements.push_back(draw_timers.GetAsMeasurement("drawarrays"));
       measurements.push_back(finish_timers.GetAsMeasurement("finish"));
     }
     return measurements;
   }
 
   void RunUploadAndDrawMultipleTimes(const gfx::Size& size,
                                      const GLenum format,
                                      const bool subimage) {
-    std::vector<uint8> pixels;
+    std::vector<uint8_t> pixels;
     base::SmallMap<std::map<std::string, Measurement>>
         aggregates;  // indexed by name
     int successful_runs = 0;
     GLuint texture_id = CreateGLTexture(format, size, subimage);
     for (int i = 0; i < kUploadPerfWarmupRuns + kUploadPerfTestRuns; ++i) {
       GenerateTextureData(size, GLFormatBytePerPixel(format), i + 1, &pixels);
       auto run = UploadAndDraw(texture_id, size, pixels, format, subimage);
       if (i < kUploadPerfWarmupRuns || !run.size()) {
         continue;
       }
@@ skipping 79 matching lines @@
 // every image it uploads it using texture_id and it draws multiple
 // times. The cpu/wall time and the gpu time for all the uploads and
 // draws, but before glFinish, is computed and is printed out at the end as
 // "upload_and_draw". If the gpu time is >> than the cpu/wall time we expect the
 // driver to do texture renaming: this means that while the gpu is drawing using
 // texture_id it didn't block cpu side the texture upload using the same
 // texture_id.
 TEST_F(TextureUploadPerfTest, renaming) {
   gfx::Size texture_size(fbo_size_.width() / 2, fbo_size_.height() / 2);
 
-  std::vector<uint8> pixels[4];
+  std::vector<uint8_t> pixels[4];
   for (int i = 0; i < 4; ++i) {
     GenerateTextureData(texture_size, 4, i + 1, &pixels[i]);
   }
 
   ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get());
   GenerateVertexBuffer(texture_size);
 
   gfx::Vector2dF positions[] = {gfx::Vector2dF(0.f, 0.f),
                                 gfx::Vector2dF(1.f, 0.f),
                                 gfx::Vector2dF(0.f, 1.f),
@@ skipping 16 matching lines @@
 
   upload_and_draw_timers.Record();
   MeasurementTimers finish_timers(gpu_timing_client_.get());
   glFinish();
   CheckNoGlError("glFinish");
   finish_timers.Record();
 
   glDeleteTextures(1, &texture_id);
 
   for (int i = 0; i < 4; ++i) {
-    std::vector<uint8> pixels_rendered(texture_size.GetArea() * 4);
+    std::vector<uint8_t> pixels_rendered(texture_size.GetArea() * 4);
     glReadPixels(texture_size.width() * positions[i].x(),
                  texture_size.height() * positions[i].y(), texture_size.width(),
                  texture_size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError("glReadPixels");
     ASSERT_EQ(pixels[i].size(), pixels_rendered.size());
     EXPECT_EQ(pixels[i], pixels_rendered);
   }
 
   bool gpu_timer_errors = gpu_timing_client_->IsAvailable() &&
                           gpu_timing_client_->CheckAndResetTimerErrors();
   if (!gpu_timer_errors) {
     upload_and_draw_timers.GetAsMeasurement("upload_and_draw")
         .PrintResult("renaming");
     finish_timers.GetAsMeasurement("finish").PrintResult("renaming");
   }
 }
 
 }  // namespace
 }  // namespace gpu