eliminate the non-vbo code path

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 50 matching lines @@
     if (Bench(f, &slope, &bias)) {
       printf("%s: %g\n", name, coefficient * (inverse ? 1.f / slope : slope));
     } else {
       printf("# %s is too slow, returning zero.\n", name);
       printf("%s: 0\n", name);
     }
   }
 }
 
 static int arg1 = 0;
-static void *arg2 = NULL;
 
 void SwapTestFunc(int iter) {
   for (int i = 0 ; i < iter; ++i) {
     SwapBuffers();
   }
 }
 
 void SwapTest() {
   RunTest(SwapTestFunc, "us_swap_swap", 1.f, false);
 }
@@ skipping 27 matching lines @@
   RunTest(ClearTestFunc, "mpixels_sec_clear_colordepthstencil",
           g_width * g_height, true);
 }
 
 
 GLuint SetupVBO(GLenum target, GLsizeiptr size, const GLvoid *data) {
   GLuint buf = ~0;
   glGenBuffers(1, &buf);
   glBindBuffer(target, buf);
   glBufferData(target, size, data, GL_STATIC_DRAW);
-
-  return glGetError() == 0 ? buf : 0;
+  CHECK(!glGetError());

[Alexey Marinichev, 2010/03/25 21:01:57]

I personally prefer explicit comparisons for ints (I use bang on bools), don't
know what our official conventions say.  Up to you.

+  return buf;
 }
 
 
 GLuint SetupTexture(GLsizei size_log2) {
   GLsizei size = 1 << size_log2;
   GLuint name = ~0;
   glGenTextures(1, &name);
   glBindTexture(GL_TEXTURE_2D, name);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ skipping 45 matching lines @@
   GLfloat buffer_texture[8] = {
     0.f, 0.f,
     1.f, 0.f,
     0.f, 1.f,
     1.f, 1.f,
   };
   glEnableClientState(GL_VERTEX_ARRAY);
 
   GLuint vbo_vertex = SetupVBO(GL_ARRAY_BUFFER,
                                sizeof(buffer_vertex), buffer_vertex);
-  if (!vbo_vertex)
-    printf("# Not Using VBO!\n");
-  glVertexPointer(2, GL_FLOAT, 0, vbo_vertex ? 0 : buffer_vertex);
+  glVertexPointer(2, GL_FLOAT, 0, 0);
 
   GLuint vbo_texture = SetupVBO(GL_ARRAY_BUFFER,
                                 sizeof(buffer_texture), buffer_texture);
-  glTexCoordPointer(2, GL_FLOAT, 0, vbo_texture ? 0 : buffer_texture);
+  glTexCoordPointer(2, GL_FLOAT, 0, 0);
 
   glColor4f(1.f, 0.f, 0.f, 1.f);
   FillRateTestNormal("fill_solid");
   FillRateTestBlendDepth("fill_solid");
 
   glColor4f(1.f, 1.f, 1.f, 1.f);
   glEnableClientState(GL_TEXTURE_COORD_ARRAY);
   glEnable(GL_TEXTURE_2D);
 
   GLuint texture = SetupTexture(9);
@@ skipping 64 matching lines @@
 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);
   }
 }
 
 
 static void DrawElementsTestFunc(int iter) {
-  glDrawElements(GL_TRIANGLES, arg1, GL_UNSIGNED_INT, arg2);
+  glDrawElements(GL_TRIANGLES, arg1, GL_UNSIGNED_INT, 0);
   glFlush();
   for (int i = 0 ; i < iter-1; ++i) {
-    glDrawElements(GL_TRIANGLES, arg1, GL_UNSIGNED_INT, arg2);
+    glDrawElements(GL_TRIANGLES, arg1, GL_UNSIGNED_INT, 0);
   }
 }
 
 // Generates a tautological lattice.
 static void CreateLattice(GLfloat **vertices, GLsizeiptr *size,
                           GLfloat size_x, GLfloat size_y,
                           int width, int height)
 {
   GLfloat *vptr = *vertices = new GLfloat[2 * (width + 1) * (height + 1)];
   for (int j = 0; j <= height; j++) {
@@ skipping 47 matching lines @@
   // 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,
                 width, height);
   GLuint vertex_buffer = SetupVBO(GL_ARRAY_BUFFER,
                                   vertex_buffer_size, vertices);
-  glVertexPointer(2, GL_FLOAT, 0, vertex_buffer != 0 ? 0 : vertices);
+  glVertexPointer(2, GL_FLOAT, 0, 0);
   glEnableClientState(GL_VERTEX_ARRAY);
 
   GLuint *indices = NULL;
   GLuint index_buffer = 0;
   GLsizeiptr index_buffer_size = 0;
 
   {
     arg1 = CreateMesh(&indices, &index_buffer_size, width, height, 0);
 
     index_buffer = SetupVBO(GL_ELEMENT_ARRAY_BUFFER,
                             index_buffer_size, indices);
-    arg2 = index_buffer ? 0 : indices;
-
     RunTest(DrawElementsTestFunc, "mtri_sec_triangle_setup", arg1 / 3, true);
     glEnable(GL_CULL_FACE);
     RunTest(DrawElementsTestFunc, "mtri_sec_triangle_setup_all_culled",
             arg1 / 3, true);
     glDisable(GL_CULL_FACE);
 
     glDeleteBuffers(1, &index_buffer);
     delete[] indices;
   }
 
   {
     glColor4f(0.f, 1.f, 1.f, 1.f);
     arg1 = CreateMesh(&indices, &index_buffer_size, width, height,
                       RAND_MAX / 2);
 
     index_buffer = SetupVBO(GL_ELEMENT_ARRAY_BUFFER,
                             index_buffer_size, indices);
-    arg2 = index_buffer ? 0 : indices;
-
     glEnable(GL_CULL_FACE);
     RunTest(DrawElementsTestFunc, "mtri_sec_triangle_setup_half_culled",
             arg1 / 3, true);
 
     glDeleteBuffers(1, &index_buffer);
     delete[] indices;
   }
 
   glDeleteBuffers(1, &vertex_buffer);
   delete[] vertices;
@@ skipping 307 matching lines @@
   // Set up the vertex arrays for drawing textured quads later on.
   glEnableClientState(GL_VERTEX_ARRAY);
   GLfloat buffer_vertex[8] = {
     -1.f, -1.f,
     1.f,  -1.f,
     -1.f, 1.f,
     1.f,  1.f,
   };
   GLuint vbo_vertex = SetupVBO(GL_ARRAY_BUFFER,
                                sizeof(buffer_vertex), buffer_vertex);
-  if (!vbo_vertex)
-    printf("# Not Using VBO!\n");
-  glVertexPointer(2, GL_FLOAT, 0, vbo_vertex ? 0 : buffer_vertex);
+  glVertexPointer(2, GL_FLOAT, 0, 0);
 
   GLfloat buffer_texture[8] = {
     0.f, 0.f,
     1.f, 0.f,
     0.f, 1.f,
     1.f, 1.f,
   };
   GLuint vbo_texture = SetupVBO(GL_ARRAY_BUFFER,
                                 sizeof(buffer_texture), buffer_texture);
   for (int i = 0; i < 3; i++) {
     glClientActiveTexture(GL_TEXTURE0 + i);
-    glTexCoordPointer(2, GL_FLOAT, 0, vbo_texture ? 0 : buffer_texture);
+    glTexCoordPointer(2, GL_FLOAT, 0, 0);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
   }
 
   // Set up the static background textures.
   UpdateTexture();
   UpdateTexture();
   UpdateTexture();
   // Load these textures into bound texture ids and keep using them
   // from there to avoid having to reload this texture every frame
   glActiveTexture(GL_TEXTURE0);
@@ skipping 20 matching lines @@
   compositing_background_program =
       TripleTextureBlendShaderProgram(vbo_vertex,
                                       vbo_texture, vbo_texture, vbo_texture);
   compositing_foreground_program =
       BasicTextureShaderProgram(vbo_vertex, vbo_texture);
   if ((!compositing_background_program) ||
       (!compositing_foreground_program)) {
     printf("# Could not set up compositing shader.\n");
   }
 
-  if (!vbo_vertex)
-    printf("# Not Using VBO!\n");
-  glVertexPointer(2, GL_FLOAT, 0, vbo_vertex ? 0 : buffer_vertex);
+  glVertexPointer(2, GL_FLOAT, 0, 0);
 }
 
 void TeardownCompositing() {
   glDeleteProgram(compositing_background_program);
   glDeleteProgram(compositing_foreground_program);
 }
 
 // Notes on the window manager compositing test:
 // Depth
 //      Depth complexity = 3: background, active window, static window
@@ skipping 77 matching lines @@
       test[i]();
       GLenum err = glGetError();
       if (err != 0)
         printf("# glGetError returned non-zero: 0x%x\n", err);
       DestroyContext();
     }
   } while (GetUTime() < done);
 
   return 0;
 }