Implements glGetVertexAttribPointerv

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 <stdio.h>
 
 #include <vector>
 #include <string>
@@ skipping 395 matching lines @@
     bool CanAccess(GLuint index);
 
     void set_enabled(bool enabled) {
       enabled_ = enabled;
     }
 
     GLuint buffer() const {
       return buffer_;
     }
 
+    GLsizei offset() const {
+      return offset_;
+    }
+
     void Clear() {
       buffer_ = 0;
       SetBufferSize(0);
     }
 
     void SetBufferSize(GLsizeiptr buffer_size) {
       buffer_size_ = buffer_size;
       if (offset_ > buffer_size || real_stride_ == 0) {
         num_elements_ = 0;
       } else {
@@ skipping 1293 matching lines @@
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
     if (!data) {
       return parse_error::kParseOutOfBounds;
     }
   }
   // TODO(gman): Validate internal_format
   if (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   scoped_array<int8> zero;
   if (!data) {
     zero.reset(new int8[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCompressedTexImage2DImmediate(
     uint32 immediate_data_size, const gles2::CompressedTexImage2DImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
   const void* data = GetImmediateDataAs<const void*>(
       c, image_size, immediate_data_size);
   if (!data) {
     return parse_error::kParseOutOfBounds;
   }
   // TODO(gman): Validate internal_format
   if (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleTexImage2D(
     uint32 immediate_data_size, const gles2::TexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
@@ skipping 13 matching lines @@
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
       return parse_error::kParseOutOfBounds;
     }
   }
   if (!ValidateGLenumTextureTarget(target) ||
       !ValidateGLenumTextureFormat(internal_format) ||
       !ValidateGLenumTextureFormat(format) ||
       !ValidateGLenumPixelType(type)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   scoped_array<int8> zero;
   if (!pixels) {
     zero.reset(new int8[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     pixels = zero.get();
   }
   glTexImage2D(
       target, level, internal_format, width, height, border, format, type,
@@ skipping 15 matching lines @@
       width, height, format, type, unpack_alignment_);
   const void* pixels = GetImmediateDataAs<const void*>(
       c, size, immediate_data_size);
   if (!pixels) {
     return parse_error::kParseOutOfBounds;
   }
   if (!ValidateGLenumTextureTarget(target) ||
       !ValidateGLenumTextureFormat(internal_format) ||
       !ValidateGLenumTextureFormat(format) ||
       !ValidateGLenumPixelType(type)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetVertexAttribPointerv(
     uint32 immediate_data_size, const gles2::GetVertexAttribPointerv& c) {
-  // TODO(gman): Implement.
+  GLuint index = static_cast<GLuint>(c.index);
+  GLenum pname = static_cast<GLenum>(c.pname);
+  SizedResult* result = GetSharedMemoryAs<SizedResult*>(
+      c.pointer_shm_id, c.pointer_shm_offset, sizeof(SizedResult));
+  if (!result) {
+    return parse_error::kParseOutOfBounds;
+  }
+  result->size = 0;
+  if (!ValidateGLenumVertexPointer(pname)) {
+    SetGLError(GL_INVALID_ENUM);
+    return parse_error::kParseNoError;
+  }
+  if (index >= max_vertex_attribs_) {
+    SetGLError(GL_INVALID_VALUE);
+    return parse_error::kParseNoError;
+  }
+  result->size = sizeof(GLuint);
+  *result->GetDataAs<GLuint*>() = vertex_attrib_infos_[index].offset();
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetUniformiv(
     uint32 immediate_data_size, const gles2::GetUniformiv& c) {
   // TODO(gman): Implement.
+  NOTREACHED();
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetUniformfv(
     uint32 immediate_data_size, const gles2::GetUniformfv& c) {
   // TODO(gman): Implement.
+  NOTREACHED();
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetShaderPrecisionFormat(
     uint32 immediate_data_size, const gles2::GetShaderPrecisionFormat& c) {
   // TODO(gman): Implement.
+  NOTREACHED();
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetAttachedShaders(
     uint32 immediate_data_size, const gles2::GetAttachedShaders& c) {
   // TODO(gman): Implement.
+  NOTREACHED();
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetActiveUniform(
     uint32 immediate_data_size, const gles2::GetActiveUniform& c) {
   // TODO(gman): Implement.
+  NOTREACHED();
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetActiveAttrib(
     uint32 immediate_data_size, const gles2::GetActiveAttrib& c) {
   // TODO(gman): Implement.
+  NOTREACHED();
   return parse_error::kParseNoError;
 }
 
 // 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