Replaced funky state machines with classes. This is in preparation of doing the same to gl_Bench.

client/deps/glbench/src/main.cc

 // Copyright (c) 2010 The Chromium OS 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 <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 
@@ skipping 142 matching lines @@
     glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, size, size, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   }
   delete[] pixels;
   return name;
 }
 
 
 static void DrawArraysTestFunc(int iter);
 static void FillRateTestNormal(const char *name, float coeff=1.f);
+
+#ifndef USE_EGL
 static void FillRateTestBlendDepth(const char *name);
 
 void FillRateTest() {
   glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
   glDisable(GL_DEPTH_TEST);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   GLfloat buffer_vertex[8] = {
     -1.f, -1.f,
     1.f,  -1.f,
@@ skipping 52 matching lines @@
   glLoadIdentity();
   glScalef(0.933f, 0.933f, 1.f);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                   GL_LINEAR_MIPMAP_LINEAR);
   FillRateTestNormal("fill_tex_trilinear_linear_01", 0.933f * 0.933f);
 
   glDeleteBuffers(1, &vbo_vertex);
   glDeleteBuffers(1, &vbo_texture);
   glDeleteTextures(1, &texture);
 }
+#endif
 
 
 static void FillRateTestNormal(const char *name, float coeff) {
   const int buffer_len = 64;
   char buffer[buffer_len];
   snprintf(buffer, buffer_len, "mpixels_sec_%s", name);
   RunTest(DrawArraysTestFunc, buffer, coeff * g_width * g_height, true);
 }
 
+#ifndef USE_EGL
 static void FillRateTestBlendDepth(const char *name) {
   const int buffer_len = 64;
   char buffer[buffer_len];
 
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glEnable(GL_BLEND);
   snprintf(buffer, buffer_len, "mpixels_sec_%s_blended", name);
   RunTest(DrawArraysTestFunc, buffer, g_width * g_height, true);
   glDisable(GL_BLEND);
 
   glEnable(GL_DEPTH_TEST);
   glDepthFunc(GL_NOTEQUAL);
   snprintf(buffer, buffer_len, "mpixels_sec_%s_depth_neq", name);
   RunTest(DrawArraysTestFunc, buffer, g_width * g_height, true);
   glDepthFunc(GL_NEVER);
   snprintf(buffer, buffer_len, "mpixels_sec_%s_depth_never", name);
   RunTest(DrawArraysTestFunc, buffer, g_width * g_height, true);
   glDisable(GL_DEPTH_TEST);
 }
+#endif
 
 
 static void DrawArraysTestFunc(int iter) {
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   glFlush();
   for (int i = 0; i < iter-1; ++i) {
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   }
 }
 
@@ skipping 50 matching lines @@
         *iptr++ = flag ? third : second;
         *iptr++ = flag ? second : third;
       }
     }
   }
   *size = (iptr - *indices) * sizeof(GLuint);
 
   return iptr - *indices;
 }
 
+#ifndef USE_EGL
 void TriangleSetupTest() {
   glViewport(-g_width, -g_height, g_width*2, g_height*2);
 
   // Larger meshes make this test too slow for devices that do 1 mtri/sec.
   GLint width = 64;
   GLint height = 64;
 
   GLfloat *vertices = NULL;
   GLsizeiptr vertex_buffer_size = 0;
   CreateLattice(&vertices, &vertex_buffer_size, 1.f / g_width, 1.f / g_height,
@@ skipping 33 matching lines @@
     RunTest(DrawElementsTestFunc, "mtri_sec_triangle_setup_half_culled",
             arg1 / 3, true);
 
     glDeleteBuffers(1, &index_buffer);
     delete[] indices;
   }
 
   glDeleteBuffers(1, &vertex_buffer);
   delete[] vertices;
 }
+#endif
 
 
 void AttributeFetchShaderTest() {
   GLint width = 64;
   GLint height = 64;
 
   glViewport(-g_width, -g_height, g_width*2, g_height*2);
 
   GLfloat *vertices = NULL;
   GLsizeiptr vertex_buffer_size = 0;
@@ skipping 166 matching lines @@
 }
 
 void YuvToRgbShaderTest1() {
   YuvToRgbShaderTestHelper(1, "yuv_shader_1");
 }
 
 void YuvToRgbShaderTest2() {
   YuvToRgbShaderTestHelper(2, "yuv_shader_2");
 }
 
-static GLuint compositing_textures[5];
 static uint32_t texture_base[WINDOW_HEIGHT*WINDOW_WIDTH];
 static uint32_t texture_update[WINDOW_HEIGHT*WINDOW_WIDTH];
+#ifndef USE_EGL
+static GLuint compositing_textures[5];
 static ShaderProgram compositing_background_program = 0;
 static ShaderProgram compositing_foreground_program = 0;
+#endif
 
 void InitBaseTexture() {
   for (int y = 0; y < WINDOW_HEIGHT; y++) {
     for (int x = 0; x < WINDOW_WIDTH; x++) {
       // This color is gray, half alpha.
       texture_base[y*WINDOW_WIDTH+x] = 0x80808080;
     }
   }
 }
 
 // UpdateTexture simulates Chrome updating tab contents.
 // We cause a bunch of read and write cpu memory bandwidth.
 // It's a very rough approximation.
 void UpdateTexture() {
   memcpy(texture_update, texture_base, sizeof(texture_base));
 }
 
 void LoadTexture() {
   // Use GL_RGBA for compatibility with GLES2.0.
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                WINDOW_WIDTH, WINDOW_HEIGHT, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, texture_update);
 }
 
+#ifndef USE_EGL
 // Test how fast we can do full-screen compositing of images
 // continuously updated from the CPU.
 // This tests both GPU compositing performance and also
 // CPU -> GPU data transfer speed.
 // It is a basic perf test to make sure we have enough performance
 // to run a compositing window manager.
 void CompositingTestFunc(int iter) {
   for (int i = 0 ; i < iter; ++i) {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
@@ skipping 171 matching lines @@
 }
 
 void NoFillWindowManagerCompositingTest() {
   glScissor(0, 0, 1, 1);
   glEnable(GL_SCISSOR_TEST);
   InitializeCompositing();
   RunTest(CompositingTestFunc, "1280x768_fps_no_fill_compositing",
           screen_scale_factor, true);
   TeardownCompositing();
 }
+#endif
 
 void ReadPixelTestFunc(int iter) {
   glReadPixels(0, 0, g_width, g_height, GL_RGBA, GL_UNSIGNED_BYTE, arg2);
   CHECK(glGetError() == 0);
   for (int i = 0; i < iter; i++)
     glReadPixels(0, 0, g_width, g_height, GL_RGBA, GL_UNSIGNED_BYTE, arg2);
 }
 
 // TODO: better test names.
 void ReadPixelTest() {
@@ skipping 49 matching lines @@
   SetBasePathFromArgv0(argv[0], "src");
   ParseArgs(argc, argv);
   if (!Init()) {
     printf("# Failed to initialize.\n");
     return 1;
   }
 
   void (*test[])() = {
     SwapTest,
     ClearTest,
-    FillRateTest,
-    TriangleSetupTest,
     AttributeFetchShaderTest,
     VaryingsAndDdxyShaderTest,
     YuvToRgbShaderTest1,
     YuvToRgbShaderTest2,
+#ifndef USE_EGL
+    FillRateTest,
+    TriangleSetupTest,
     NoFillWindowManagerCompositingTest,
     WindowManagerCompositingTest,
+#endif
     ReadPixelTest,
   };
 
   uint64_t done = GetUTime() + 1000000ULL * seconds_to_run;
   do {
     for (unsigned int i = 0; i < sizeof(test) / sizeof(*test); i++) {
       InitContext();
       test[i]();
       GLenum err = glGetError();
       if (err != 0)
         printf("# glGetError returned non-zero: 0x%x\n", err);
       DestroyContext();
     }
   } while (GetUTime() < done);
 
   return 0;
 }