A bunch of unit tests for GLES2

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include <vector>
 #include <string>
 #include <map>
 #include <build/build_config.h>
 #include "base/scoped_ptr.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/gl_utils.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 
 namespace gpu {
 namespace gles2 {
 
 // Check that certain assumptions the code makes are true. There are places in
 // the code where shared memory is passed direclty to GL. Example, glUniformiv,
 // glShaderSource. The command buffer code assumes GLint and GLsizei (and maybe
 // a few others) are 32bits. If they are not 32bits the code will have to change
 // to call those GL functions with service side memory and then copy the results
@@ skipping 108 matching lines @@
       return GL_INVALID_FRAMEBUFFER_OPERATION;
     default:
       DCHECK(false);
       return GL_NO_ERROR;
   }
 }
 
 }  // anonymous namespace.
 
 #if defined(UNIT_TEST)
-GLES2Decoder::GLES2Decoder() {
+GLES2Decoder::GLES2Decoder()
+    : debug_(false) {
 #elif defined(OS_LINUX)
 GLES2Decoder::GLES2Decoder()
     : debug_(false),
       window_(NULL) {
 #elif defined(OS_WIN)
 GLES2Decoder::GLES2Decoder()
     : debug_(false),
       hwnd_(NULL) {
 #else
-GLES2Decoder::GLES2Decoder() {
+GLES2Decoder::GLES2Decoder()
+    : debug_(false) {
 #endif
 }
 
 // This class maps one set of ids to another.
 class IdMap {
  public:
   // Maps a client_id to a service_id. Return false if the client_id or
   // service_id are already mapped to something else.
   bool AddMapping(GLuint client_id, GLuint service_id);
 
@@ skipping 99 matching lines @@
       }
     }
 
     void SetInfo(
         GLuint buffer,
         GLsizeiptr buffer_size,
         GLint size,
         GLenum type,
         GLsizei real_stride,
         GLsizei offset) {
-      DCHECK(real_stride > 0);
+      DCHECK_GT(real_stride, 0);
       buffer_ = buffer;
       size_ = size;
       type_ = type;
       real_stride_ = real_stride;
       offset_ = offset;
       SetBufferSize(buffer_size);
     }
 
    private:
     // Whether or not this attribute is enabled.
@@ skipping 71 matching lines @@
 
   // Overridden from AsyncAPIInterface.
   virtual const char* GetCommandName(unsigned int command_id) const;
 
   // Overridden from GLES2Decoder.
   virtual bool Initialize();
 
   // Overridden from GLES2Decoder.
   virtual void Destroy();
 
+  // Overridden from GLES2Decoder.
+  virtual uint32 GetServiceIdForTesting(uint32 client_id);
+
   // Removes any buffers in the VertexAtrribInfos and BufferInfos. This is used
   // on glDeleteBuffers so we can make sure the user does not try to render
   // with deleted buffers.
   void RemoveBufferInfo(GLuint buffer_id);
 
  private:
   bool InitPlatformSpecific();
   bool InitGlew();
 
   // Template to help call glGenXXX functions.
   template <void gl_gen_function(GLES2DecoderImpl*, GLsizei, GLuint*)>
   bool GenGLObjects(GLsizei n, const GLuint* client_ids) {
-    // TODO(gman): Verify client ids are unused.
+    if (n < 0) {
+      SetGLError(GL_INVALID_VALUE);
+      return true;
+    }
+    if (!ValidateIdsAreUnused(n, client_ids)) {
+      return false;
+    }
     scoped_array<GLuint>temp(new GLuint[n]);
     gl_gen_function(this, n, temp.get());
-    // TODO(gman): check for success before copying results.
     return RegisterObjects(n, client_ids, temp.get());
   }
 
   // Template to help call glDeleteXXX functions.
   template <void gl_delete_function(GLES2DecoderImpl*, GLsizei, GLuint*)>
   bool DeleteGLObjects(GLsizei n, const GLuint* client_ids) {
     scoped_array<GLuint>temp(new GLuint[n]);
     UnregisterObjects(n, client_ids, temp.get());
     gl_delete_function(this, n, temp.get());
     return true;
   }
 
+  // Check that the given ids are not used.
+  bool ValidateIdsAreUnused(GLsizei n, const GLuint* client_ids);
+
   // Register client ids with generated service ids.
   bool RegisterObjects(
       GLsizei n, const GLuint* client_ids, const GLuint* service_ids);
 
   // Unregisters client ids with service ids.
   void UnregisterObjects(
     GLsizei n, const GLuint* client_ids, GLuint* service_ids);
 
   // Gets the program info for the given program. Returns NULL if none exists.
   // Programs that have no had glLinkProgram succesfully called on them will
@@ skipping 159 matching lines @@
   GLint value;
   glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value);
   max_vertex_attribs_ = value;
 
   DCHECK_GE(max_vertex_attribs_, 8u);
 
   vertex_attrib_infos_.reset(new VertexAttribInfo[max_vertex_attribs_]);
   memset(vertex_attrib_infos_.get(), 0,
          sizeof(vertex_attrib_infos_[0]) * max_vertex_attribs_);
 
-  //glBindFramebuffer(0, 0);
+  // glBindFramebuffer(0, 0);
   return true;
 }
 
 namespace {
 
 #if defined(UNIT_TEST)
 #elif defined(OS_WIN)
 
 const PIXELFORMATDESCRIPTOR kPixelFormatDescriptor = {
   sizeof(kPixelFormatDescriptor),    // Size of structure.
@@ skipping 202 matching lines @@
   glDeleteRenderbuffersEXT(n, ids);
 }
 
 void GLDeleteTexturesHelper(
     GLES2DecoderImpl*, GLsizei n, GLuint* ids) {
   glDeleteTextures(n, ids);
 }
 
 }  // anonymous namespace
 
+uint32 GLES2DecoderImpl::GetServiceIdForTesting(uint32 client_id) {
+#if defined(UNIT_TEST)
+  GLuint service_id;
+  bool result = id_map_.GetServiceId(client_id, &service_id);
+  return result ? service_id : 0u;
+#else
+  DCHECK(false);
+  return 0u;
+#endif
+}
+
+bool GLES2DecoderImpl::ValidateIdsAreUnused(
+    GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    GLuint service_id;
+    if (id_map_.GetServiceId(client_ids[ii], &service_id)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool GLES2DecoderImpl::RegisterObjects(
     GLsizei n, const GLuint* client_ids, const GLuint* service_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (!id_map_.AddMapping(client_ids[ii], service_ids[ii])) {
-      // TODO(gman): fail.
+      NOTREACHED();
+      return false;
     }
   }
   return true;
 }
 
 void GLES2DecoderImpl::UnregisterObjects(
     GLsizei n, const GLuint* client_ids, GLuint* service_ids) {
-  // TODO(gman): check for success before copying results.
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (id_map_.GetServiceId(client_ids[ii], &service_ids[ii])) {
       id_map_.RemoveMapping(client_ids[ii], service_ids[ii]);
     } else {
       service_ids[ii] = 0;
     }
   }
 }
 
 void GLES2DecoderImpl::RemoveBufferInfo(GLuint buffer_id) {
@@ skipping 194 matching lines @@
     default:
       DCHECK(false);  // Validation should prevent us getting here.
       break;
   }
   glBindBuffer(target, buffer);
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (index < max_vertex_attribs_) {
     vertex_attrib_infos_[index].set_enabled(false);
-    glEnableVertexAttribArray(index);
+    glDisableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE);
   }
 }
 
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
   if (index < max_vertex_attribs_) {
     vertex_attrib_infos_[index].set_enabled(true);
     glEnableVertexAttribArray(index);
   } else {
@@ skipping 283 matching lines @@
     uint32 immediate_data_size, const gles2::VertexAttribPointer& c) {
   if (bound_array_buffer_ != 0) {
     GLuint indx = c.indx;
     GLint size = c.size;
     GLenum type = c.type;
     GLboolean normalized = c.normalized;
     GLsizei stride = c.stride;
     GLsizei offset = c.offset;
     const void* ptr = reinterpret_cast<const void*>(offset);
     if (!ValidateGLenumVertexAttribType(type) ||
-        !ValidateGLenumVertexAttribSize(size) ||
+        !ValidateGLintVertexAttribSize(size) ||
         indx >= max_vertex_attribs_ ||
         stride < 0) {
       SetGLError(GL_INVALID_VALUE);
       return parse_error::kParseNoError;
     }
     const BufferInfo* buffer_info = GetBufferInfo(bound_array_buffer_);
     GLsizei component_size = GetGLTypeSize(type);
     GLsizei real_stride = stride != 0 ? stride : component_size * size;
     if (offset % component_size > 0) {
       SetGLError(GL_INVALID_VALUE);
@@ skipping 35 matching lines @@
   }
   glReadPixels(x, y, width, height, format, type, pixels);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandlePixelStorei(
     uint32 immediate_data_size, const gles2::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
   if (!ValidateGLenumPixelStore(pname) ||
-      !ValidateGLenumPixelStoreAlignment(param)) {
+      !ValidateGLintPixelStoreAlignment(param)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   glPixelStorei(pname, param);
   switch (pname) {
   case GL_PACK_ALIGNMENT:
       pack_alignment_ = param;
       break;
   case GL_UNPACK_ALIGNMENT:
       unpack_alignment_ = param;
@@ skipping 322 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu