Added support for glGetString, glGetShaderSource,...

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 <algorithm>
 #include <vector>
@@ skipping 85 matching lines @@
 const CommandInfo g_command_info[] = {
   #define GLES2_CMD_OP(name) {                                            \
     name::kArgFlags,                                                      \
     sizeof(name) / sizeof(CommandBufferEntry) - 1, },  /* NOLINT */       \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 };
 
-namespace GLErrorBit {
-enum GLErrorBit {
-  kNoError = 0,
-  kInvalidEnum = (1 << 0),
-  kInvalidValue = (1 << 1),
-  kInvalidOperation = (1 << 2),
-  kOutOfMemory = (1 << 3),
-  kInvalidFrameBufferOperation = (1 << 4),
-};
-}
-
-uint32 GLErrorToErrorBit(GLenum error) {
-  switch (error) {
-    case GL_INVALID_ENUM:
-      return GLErrorBit::kInvalidEnum;
-    case GL_INVALID_VALUE:
-      return GLErrorBit::kInvalidValue;
-    case GL_INVALID_OPERATION:
-      return GLErrorBit::kInvalidOperation;
-    case GL_OUT_OF_MEMORY:
-      return GLErrorBit::kOutOfMemory;
-    case GL_INVALID_FRAMEBUFFER_OPERATION:
-      return GLErrorBit::kInvalidFrameBufferOperation;
-    default:
-      DCHECK(false);
-      return GLErrorBit::kNoError;
-  }
-}
-
-GLenum GLErrorBitToGLError(uint32 error_bit) {
-  switch (error_bit) {
-    case GLErrorBit::kInvalidEnum:
-      return GL_INVALID_ENUM;
-    case GLErrorBit::kInvalidValue:
-      return GL_INVALID_VALUE;
-    case GLErrorBit::kInvalidOperation:
-      return GL_INVALID_OPERATION;
-    case GLErrorBit::kOutOfMemory:
-      return GL_OUT_OF_MEMORY;
-    case GLErrorBit::kInvalidFrameBufferOperation:
-      return GL_INVALID_FRAMEBUFFER_OPERATION;
-    default:
-      DCHECK(false);
-      return GL_NO_ERROR;
-  }
-}
-
 // }  // anonymous namespace.
 
 GLES2Decoder::GLES2Decoder(ContextGroup* group)
     : group_(group),
 #if defined(UNIT_TEST)
       debug_(false) {
 #elif defined(OS_LINUX)
       debug_(false),
       window_(NULL) {
 #elif defined(OS_WIN)
@@ skipping 318 matching lines @@
 
   // Wrapper for glDisableVertexAttribArray.
   void DoDisableVertexAttribArray(GLuint index);
 
   // Wrapper for glEnableVertexAttribArray.
   void DoEnableVertexAttribArray(GLuint index);
 
   // Wrapper for glGenerateMipmap
   void DoGenerateMipmap(GLenum target);
 
+  // Wrapper for glGetShaderiv
+  void DoGetShaderiv(GLuint shader, GLenum pname, GLint* params);
+
   // Wrapper for glGetShaderSource.
   void DoGetShaderSource(
       GLuint shader, GLsizei bufsize, GLsizei* length, char* dst);
 
   // Wrapper for glLinkProgram
   void DoLinkProgram(GLuint program);
 
   // Swaps the buffers (copies/renders to the current window).
   void DoSwapBuffers();
 
@@ skipping 1294 matching lines @@
   current_program_ = info;
   glUseProgram(program);
 }
 
 GLenum GLES2DecoderImpl::GetGLError() {
   // Check the GL error first, then our wrapped error.
   GLenum error = glGetError();
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
-        error = GLErrorBitToGLError(mask);
+        error = GLES2Util::GLErrorBitToGLError(mask);
         break;
       }
     }
   }
 
   if (error != GL_NO_ERROR) {
     // There was an error, clear the corresponding wrapped error.
-    error_bits_ &= ~GLErrorToErrorBit(error);
+    error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
   }
   return error;
 }
 
 void GLES2DecoderImpl::SetGLError(GLenum error) {
-  error_bits_ |= GLErrorToErrorBit(error);
+  error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
 void GLES2DecoderImpl::CopyRealGLErrorsToWrapper() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
     SetGLError(error);
   }
 }
 
 bool GLES2DecoderImpl::VertexAttribInfo::CanAccess(GLuint index) {
@@ skipping 211 matching lines @@
     return;
   }
   // TODO(gman): Run shader through compiler that converts GL ES 2.0 shader
   // to DesktopGL shader and pass that to glShaderSource and then
   // glCompileShader.
   const char* ptr = info->source().c_str();
   glShaderSource(shader, 1, &ptr, NULL);
   glCompileShader(shader);
 };
 
+void GLES2DecoderImpl::DoGetShaderiv(
+    GLuint shader, GLenum pname, GLint* params) {
+  ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
+  if (!info) {
+    SetGLError(GL_INVALID_OPERATION);
+    return;
+  }
+  if (pname == GL_SHADER_SOURCE_LENGTH) {
+    *params = info->source().size();
+  } else {
+    glGetShaderiv(shader, pname, params);
+  }
+}
+
 void GLES2DecoderImpl::DoGetShaderSource(
       GLuint shader, GLsizei bufsize, GLsizei* length, char* dst) {
   ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   const std::string& source = info->source();
   GLsizei size = std::min(bufsize - 1, static_cast<GLsizei>(source.size()));
   if (length) {
@@ skipping 209 matching lines @@
   GLint* location = GetSharedMemoryAs<GLint*>(
       c.location_shm_id, c.location_shm_offset, sizeof(GLint));
   if (!location || !name) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
   *location = info->GetUniformLocation(name_str);
   return error::kNoError;
 }
 
+error::Error GLES2DecoderImpl::HandleGetString(
+    uint32 immediate_data_size, const gles2::GetString& c) {
+  GLenum name = static_cast<GLenum>(c.name);
+  if (!ValidateGLenumStringType(name)) {
+    SetGLError(GL_INVALID_ENUM);
+    return error::kNoError;
+  }
+  Bucket* bucket = CreateBucket(c.bucket_id);
+  bucket->SetFromString(reinterpret_cast<const char*>(glGetString(name)));
+  return error::kNoError;
+}
+
 error::Error GLES2DecoderImpl::HandleBufferData(
     uint32 immediate_data_size, const gles2::BufferData& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
   uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
   GLenum usage = static_cast<GLenum>(c.usage);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(data_shm_id, data_shm_offset, size);
@@ skipping 140 matching lines @@
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
   const void* data = GetImmediateDataAs<const void*>(
       c, image_size, immediate_data_size);
   if (!data) {
     return error::kOutOfBounds;
   }
   return DoCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
 }
 
-// TODO(gman): handle CopyTexImage2D because we need to track what was created.
-
 error::Error GLES2DecoderImpl::DoTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLenum format,
   GLenum type,
   const void* pixels,
@@ skipping 342 matching lines @@
   return error::kNoError;
 }
 
 // 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