Makes shader translation a runtime switch....

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 <list>
@@ skipping 786 matching lines @@
   void DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
-  // Helper for CommandBufferEnable cmd.
-  void DoCommandBufferEnable(GLenum pname, GLboolean enable);
-
   // Wrapper for glCompileShader.
   void DoCompileShader(GLuint shader);
 
   // Helper for DeleteSharedIds commands.
   void DoDeleteSharedIds(GLuint namespace_id, GLsizei n, const GLuint* ids);
 
   // Wrapper for glDetachShader
   void DoDetachShader(GLuint client_program_id, GLint client_shader_id);
 
   // Wrapper for glDrawArrays.
@@ skipping 252 matching lines @@
   scoped_ptr<RenderBuffer> offscreen_target_depth_stencil_render_buffer_;
 
   // The copy that is saved when SwapBuffers is called.
   scoped_ptr<Texture> offscreen_saved_color_texture_;
 
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
 
   // The last error message set.
   std::string last_error_;
 
+  bool use_shader_translator_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   decoder_->ClearRealGLErrors();
@@ skipping 242 matching lines @@
 GLES2DecoderImpl::GLES2DecoderImpl(ContextGroup* group)
     : GLES2Decoder(group),
       context_(NULL),
       error_bits_(0),
       util_(0),  // TODO(gman): Set to actual num compress texture formats.
       pack_alignment_(4),
       unpack_alignment_(4),
       active_texture_unit_(0),
       black_2d_texture_id_(0),
       black_cube_texture_id_(0),
-      anti_aliased_(false) {
+      anti_aliased_(false),
+      use_shader_translator_(true) {
 }
 
 bool GLES2DecoderImpl::Initialize(gfx::GLContext* context,
                                   const gfx::Size& size,
                                   GLES2Decoder* parent,
                                   uint32 parent_client_texture_id) {
   DCHECK(context);
   DCHECK(!context_);
   context_ = context;
 
@@ skipping 993 matching lines @@
       program, "glBindAttribLocation");
   if (!info) {
     return error::kNoError;
   }
   GLuint index = static_cast<GLuint>(c.index);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
-  bucket->GetAsString(&name_str);
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
   glBindAttribLocation(info->service_id(), index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteShader(
     uint32 immediate_data_size, const gles2::DeleteShader& c) {
   GLuint client_id = c.shader;
   if (client_id) {
     ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
     if (info) {
@@ skipping 692 matching lines @@
   ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
       client_id, "glCompileShader");
   if (!info) {
     return;
   }
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
   const char* shader_src = info->source().c_str();
 #if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2) && !defined(UNIT_TEST)
 #if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
-  int dbg_options = 0;
-  EShLanguage language = info->shader_type() == GL_VERTEX_SHADER ?
-      EShLangVertex : EShLangFragment;
-  TBuiltInResource resources;
-  // TODO(alokp): Ask gman how to get appropriate values.
-  resources.maxVertexAttribs = 8;
-  resources.maxVertexUniformVectors = 128;
-  resources.maxVaryingVectors = 8;
-  resources.maxVertexTextureImageUnits = 0;
-  resources.maxCombinedTextureImageUnits = 8;
-  resources.maxTextureImageUnits = 8;
-  resources.maxFragmentUniformVectors = 16;
-  resources.maxDrawBuffers = 1;
-  ShHandle compiler = ShConstructCompiler(language, dbg_options);
-  if (!ShCompile(compiler, &shader_src, 1, EShOptNone, &resources,
-                 dbg_options)) {
-    // TODO(alokp): Ask gman where to set compile-status and info-log.
-    // May be add member variables to ShaderManager::ShaderInfo?
-    //const char* info_log = ShGetInfoLog(compiler);
-    ShDestruct(compiler);
-    return;
+  ShHandle compiler;
+  if (use_shader_translator_) {
+    int dbg_options = 0;
+    EShLanguage language = info->shader_type() == GL_VERTEX_SHADER ?
+        EShLangVertex : EShLangFragment;
+    TBuiltInResource resources;
+    // TODO(alokp): Ask gman how to get appropriate values.
+    resources.maxVertexAttribs = group_->max_vertex_attribs();
+    resources.maxVertexUniformVectors = 128;
+    resources.maxVaryingVectors = 8;
+    resources.maxVertexTextureImageUnits = 0;
+    resources.maxCombinedTextureImageUnits = group_->max_texture_units();
+    resources.maxTextureImageUnits = 8;
+    resources.maxFragmentUniformVectors = 16;
+    resources.maxDrawBuffers = 1;
+    compiler = ShConstructCompiler(language, dbg_options);
+    if (!ShCompile(compiler, &shader_src, 1, EShOptNone, &resources,
+                   dbg_options)) {
+      // TODO(alokp): Ask gman where to set compile-status and info-log.
+      // May be add member variables to ShaderManager::ShaderInfo?
+      // const char* info_log = ShGetInfoLog(compiler);
+      ShDestruct(compiler);
+      return;
+    }
+    shader_src = ShGetObjectCode(compiler);
   }
-  shader_src = ShGetObjectCode(compiler);
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 #endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 
   shader_src = info->source().c_str();
   glShaderSource(info->service_id(), 1, &shader_src, NULL);
   glCompileShader(info->service_id());
 
 #if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2) && !defined(UNIT_TEST)
 #ifdef GLES2_GPU_SERVICE_TRANSLATE_SHADER
-  ShDestruct(compiler);
+  if (use_shader_translator_) {
+    ShDestruct(compiler);
+  }
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 #endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 };
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader, GLenum pname, GLint* params) {
   ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
       shader, "glGetShaderiv");
   if (!info) {
     return;
@@ skipping 373 matching lines @@
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttribLocationBucket(
     uint32 immediate_data_size, const gles2::GetAttribLocationBucket& c) {
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
-  bucket->GetAsString(&name_str);
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::GetUniformLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       client_id, "glUniformLocation");
   if (!info) {
@@ skipping 44 matching lines @@
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformLocationBucket(
     uint32 immediate_data_size, const gles2::GetUniformLocationBucket& c) {
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
-  bucket->GetAsString(&name_str);
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 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, "glGetString: name GL_INVALID_ENUM");
     return error::kNoError;
@@ skipping 698 matching lines @@
   // glReadPixels. After the callback runs, the multisampled frame buffer
   // needs to be bound again.
 
   if (swap_buffers_callback_.get()) {
     swap_buffers_callback_->Run();
   }
 
   return error::kNoError;
 }
 
-void GLES2DecoderImpl::DoCommandBufferEnable(GLenum pname, GLboolean enable) {
-  switch (pname) {
-    case GLES2_ALLOW_BUFFERS_ON_MULTIPLE_TARGETS:
-      buffer_manager()->set_allow_buffers_on_multiple_targets(enable != 0);
-      break;
-    default:
-      break;
+error::Error GLES2DecoderImpl::HandleCommandBufferEnable(
+    uint32 immediate_data_size, const gles2::CommandBufferEnable& c) {
+  Bucket* bucket = GetBucket(c.bucket_id);
+  typedef gles2::CommandBufferEnable::Result Result;
+  Result* result = GetSharedMemoryAs<Result*>(
+      c.result_shm_id, c.result_shm_offset, sizeof(*result));
+  if (!result) {
+    return error::kOutOfBounds;
   }
+  // Check that the client initialized the result.
+  if (*result != 0) {
+    return error::kInvalidArguments;
+  }
+  std::string feature_str;
+  if (!bucket->GetAsString(&feature_str)) {
+    return error::kInvalidArguments;
+  }
+
+  // TODO(gman): make this some kind of table to function pointer thingy.
+  if (feature_str.compare(PEPPER3D_ALLOW_BUFFERS_ON_MULTIPLE_TARGETS) == 0) {
+    buffer_manager()->set_allow_buffers_on_multiple_targets(true);
+  } else if (feature_str.compare(PEPPER3D_SKIP_GLSL_TRANSLATION) == 0) {
+    use_shader_translator_ = false;
+  } else {
+    return error::kNoError;
+  }
+
+  *result = 1;  // true.
+  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