Update from https://crrev.com/320931

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 <algorithm>
 #include <vector>
 
 #include "base/containers/small_map.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 16 matching lines @@
 namespace {
 
 const int kUploadPerfWarmupRuns = 10;
 const int kUploadPerfTestRuns = 100;
 
 #define SHADER(Src) #Src
 
 // clang-format off
 const char kVertexShader[] =
 SHADER(
-  uniform vec2 translation = vec2(0.0, 0.0);
+  uniform vec2 translation;
   attribute vec2 a_position;
   attribute vec2 a_texCoord;
   varying vec2 v_texCoord;
   void main() {
     gl_Position = vec4(
         translation.x + a_position.x, translation.y + a_position.y, 0.0, 1.0);
     v_texCoord = a_texCoord;
   }
 );
 const char kFragmentShader[] =
 SHADER(
+  precision mediump float;
   uniform sampler2D a_texture;
   varying vec2 v_texCoord;
   void main() {
     gl_FragColor = texture2D(a_texture, v_texCoord);
   }
 );
 // clang-format on
 
 void CheckNoGlError() {
   CHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
@@ skipping 15 matching lines @@
     if (len > 1) {
       scoped_ptr<char> error_log(new char[len]);
       glGetShaderInfoLog(shader, len, NULL, error_log.get());
       LOG(ERROR) << "Error compiling shader: " << error_log.get();
     }
   }
   CHECK_NE(0, compiled);
   return shader;
 }
 
+int GLFormatBytePerPixel(GLenum format) {
+  DCHECK(format == GL_RGBA || format == GL_LUMINANCE || format == GL_RED_EXT);
+  return format == GL_RGBA ? 4 : 1;
+}
+
 void GenerateTextureData(const gfx::Size& size,
                          int bytes_per_pixel,
                          const int seed,
                          std::vector<uint8>* const pixels) {
-  int bytes = size.GetArea() * bytes_per_pixel;
-  pixels->resize(bytes);
-  for (int i = 0; i < bytes; ++i) {
-    int channel = i % bytes_per_pixel;
-    if (channel == 3) {  // Alpha channel.
-      pixels->at(i) = 255;
-    } else {
-      pixels->at(i) = (i + (seed << 2)) % (32 << channel);
+  // 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>& pixels_rgba) {
-  for (size_t i = 0; i < pixels.size(); i += 4) {
-    switch (format) {
-      case GL_RED_EXT:  // (R_t, 0, 0, 1)
-        if (pixels_rgba[i] != pixels[i / 4] || pixels_rgba[i + 1] != 0 ||
-            pixels_rgba[i + 2] != 0 || pixels_rgba[i + 3] != 255) {
-          return false;
-        }
-        break;
-      case GL_LUMINANCE:  // (L_t, L_t, L_t, 1)
-        if (pixels_rgba[i] != pixels[i / 4] ||
-            pixels_rgba[i + 1] != pixels[i / 4] ||
-            pixels_rgba[i + 2] != pixels[i / 4] || pixels_rgba[i + 3] != 255) {
-          return false;
-        }
-        break;
-      case GL_RGBA:  // (R_t, G_t, B_t, A_t)
-        if (pixels_rgba[i] != pixels[i] ||
-            pixels_rgba[i + 1] != pixels[i + 1] ||
-            pixels_rgba[i + 2] != pixels[i + 2] ||
-            pixels_rgba[i + 3] != pixels[i + 3]) {
-          return false;
-        }
-        break;
-      default:
-        NOTREACHED();
+                               const std::vector<uint8>& 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};
+      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_EXT:  // (R_t, 0, 0, 1)n
+          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);
+          break;
+        default:
+          NOTREACHED();
+      }
+      if (memcmp(&rgba[rgba_index], expected, 4)) {
+        return false;
+      }
     }
   }
   return true;
 }
 
 // PerfTest to check costs of texture upload at different stages
 // on different platforms.
 class TextureUploadPerfTest : public testing::Test {
  public:
   TextureUploadPerfTest() : fbo_size_(1024, 1024) {}
@@ skipping 41 matching lines @@
     fragment_shader_ = LoadShader(GL_FRAGMENT_SHADER, kFragmentShader);
     program_object_ = glCreateProgram();
     CHECK_NE(0u, program_object_);
 
     glAttachShader(program_object_, vertex_shader_);
     glAttachShader(program_object_, fragment_shader_);
     glBindAttribLocation(program_object_, 0, "a_position");
     glBindAttribLocation(program_object_, 1, "a_texCoord");
     glLinkProgram(program_object_);
 
-    translation_location_ =
-        glGetUniformLocation(program_object_, "translation");
-    DCHECK_NE(-1, translation_location_);
-
     GLint linked = -1;
     glGetProgramiv(program_object_, GL_LINK_STATUS, &linked);
     CHECK_NE(0, linked);
     glUseProgram(program_object_);
     glUniform1i(sampler_location_, 0);
+    translation_location_ =
+        glGetUniformLocation(program_object_, "translation");
+    DCHECK_NE(-1, translation_location_);
+    glUniform2f(translation_location_, 0.0f, 0.0f);
 
     sampler_location_ = glGetUniformLocation(program_object_, "a_texture");
     CHECK_NE(-1, sampler_location_);
 
     glGenBuffersARB(1, &vertex_buffer_);
     CHECK_NE(0u, vertex_buffer_);
     DCHECK_NE(0u, vertex_buffer_);
     glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, 0);
     glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4,
@@ skipping 84 matching lines @@
     glFinish();
     CheckNoGlError();
     finish_timers.Record();
 
     glDeleteTextures(1, &texture_id);
 
     std::vector<uint8> pixels_rendered(size.GetArea() * 4);
     glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError();
-    EXPECT_TRUE(CompareBufferToRGBABuffer(format, pixels, pixels_rendered))
+    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("teximage2d"));
       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) {
     std::vector<uint8> pixels;
     base::SmallMap<std::map<std::string, Measurement>>
         aggregates;  // indexed by name
     int successful_runs = 0;
-    ASSERT_THAT(format, testing::AnyOf(GL_RGBA, GL_LUMINANCE, GL_RED_EXT));
     for (int i = 0; i < kUploadPerfWarmupRuns + kUploadPerfTestRuns; ++i) {
-      GenerateTextureData(size, format == GL_RGBA ? 4 : 1, i + 1, &pixels);
+      GenerateTextureData(size, GLFormatBytePerPixel(format), i + 1, &pixels);
       auto run = UploadAndDraw(size, pixels, format);
       if (i < kUploadPerfWarmupRuns || !run.size()) {
         continue;
       }
       successful_runs++;
       for (const Measurement& measurement : run) {
         auto& aggregate = aggregates[measurement.name];
         aggregate.name = measurement.name;
         aggregate.Increment(measurement);
       }
     }
-    std::string suffix = base::StringPrintf(
-        "_%d_%s", size.width(), gfx::GLEnums::GetStringEnum(format).c_str());
+    std::string graph_name = base::StringPrintf(
+        "%d_%s", size.width(), gfx::GLEnums::GetStringEnum(format).c_str());
     if (successful_runs) {
       for (const auto& entry : aggregates) {
         const auto m = entry.second.Divide(successful_runs);
-        m.PrintResult(suffix);
+        m.PrintResult(graph_name);
       }
     }
-    perf_test::PrintResult("sample_runs", suffix, "",
+    perf_test::PrintResult("sample_runs", "", graph_name,
                            static_cast<size_t>(successful_runs), "laps", true);
   }
 
   const gfx::Size fbo_size_;  // for the fbo
   scoped_refptr<gfx::GLContext> gl_context_;
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GPUTimingClient> gpu_timing_client_;
 
   GLuint color_texture_ = 0;
   GLuint framebuffer_object_ = 0;
   GLuint vertex_shader_ = 0;
   GLuint fragment_shader_ = 0;
   GLuint program_object_ = 0;
   GLint sampler_location_ = -1;
   GLint translation_location_ = -1;
   GLuint vertex_buffer_ = 0;
 };
 
 // Perf test that generates, uploads and draws a texture on a surface repeatedly
 // and prints out aggregated measurements for all the runs.
 TEST_F(TextureUploadPerfTest, glTexImage2d) {
-  int sizes[] = {128, 256, 512, 1024};
+  int sizes[] = {21, 128, 256, 512, 1024};
   std::vector<GLenum> formats;
   formats.push_back(GL_RGBA);
   // Used by default for ResourceProvider::yuv_resource_format_.
   formats.push_back(GL_LUMINANCE);
 
   ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get());
   bool has_texture_rg = gl_context_->HasExtension("GL_EXT_texture_rg") ||
                         gl_context_->HasExtension("GL_ARB_texture_rg");
 
   if (has_texture_rg) {
     // Used as ResourceProvider::yuv_resource_format_ if
-    // {ARB,EXT}_texture_rg is available.
+    // {ARB,EXT}_texture_rg are available.
     formats.push_back(GL_RED_EXT);
   }
   for (int side : sizes) {
     ASSERT_GE(fbo_size_.width(), side);
     ASSERT_GE(fbo_size_.height(), side);
     gfx::Size size(side, side);
     GenerateVertexBuffer(size);
     for (GLenum format : formats) {
       RunUploadAndDrawMultipleTimes(size, format);
     }
@@ skipping 55 matching lines @@
                  texture_size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError();
     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("");
-    finish_timers.GetAsMeasurement("finish").PrintResult("");
+    upload_and_draw_timers.GetAsMeasurement("upload_and_draw")
+        .PrintResult("renaming");
+    finish_timers.GetAsMeasurement("finish").PrintResult("renaming");
   }
 }
 
 }  // namespace
 }  // namespace gpu