Bumped ANGLE rev in which shader translator API changed. Updated shader trans...

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 1125 matching lines @@
 
   // 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_;
+  void* vertex_compiler_;
+  void* fragment_compiler_;
 
   // Cached from the context group.
   const Validators* validators_;
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
@@ skipping 245 matching lines @@
       util_(0),  // TODO(gman): Set to actual num compress texture formats.
       pack_alignment_(4),
       unpack_alignment_(4),
       attrib_0_buffer_id_(0),
       attrib_0_size_(0),
       active_texture_unit_(0),
       black_2d_texture_id_(0),
       black_cube_texture_id_(0),
       anti_aliased_(false),
       use_shader_translator_(true),
+      vertex_compiler_(NULL),
+      fragment_compiler_(NULL),
       validators_(group->validators()) {
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
 
   // The shader translator is not needed for EGL because it already uses the
   // GLSL ES syntax. It is translated for the unit tests because
   // GLES2DecoderWithShaderTest.GetShaderInfoLogValidArgs passes the empty
   // string to CompileShader and this is not a valid shader. TODO(apatrick):
@@ skipping 121 matching lines @@
   // OpenGL ES 2.0 implicitly enables the desktop GL capability
   // VERTEX_PROGRAM_POINT_SIZE and doesn't expose this enum. This fact
   // isn't well documented; it was discovered in the Khronos OpenGL ES
   // mailing list archives.
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
   }
 
 #if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
   // Initialize GLSL ES to GLSL translator.
-  static bool glsl_translator_initialized = false;
-  if (!glsl_translator_initialized) {
-    if (!ShInitialize()) {
-      DLOG(ERROR) << "Could not initialize GLSL translator.";
+  if (!ShInitialize()) {
+    DLOG(ERROR) << "Could not initialize GLSL translator.";
+    Destroy();
+    return false;
+  }
+
+  TBuiltInResource resources;
+  resources.maxVertexAttribs = group_->max_vertex_attribs();
+  resources.maxVertexUniformVectors =
+      group_->max_vertex_uniform_vectors();
+  resources.maxVaryingVectors = group_->max_varying_vectors();
+  resources.maxVertexTextureImageUnits =
+      group_->max_vertex_texture_image_units();
+  resources.maxCombinedTextureImageUnits = group_->max_texture_units();
+  resources.maxTextureImageUnits = group_->max_texture_image_units();
+  resources.maxFragmentUniformVectors =
+      group_->max_fragment_uniform_vectors();
+  resources.maxDrawBuffers = 1;
+  vertex_compiler_ = ShConstructCompiler(EShLangVertex, EShSpecGLES2,
+      &resources);
+  if (vertex_compiler_ == NULL) {
+      DLOG(ERROR) << "Could not create vertex shader translator.";
       Destroy();
       return false;
-    }
-    glsl_translator_initialized = true;
   }
+  fragment_compiler_ = ShConstructCompiler(EShLangFragment, EShSpecGLES2,
+      &resources);
+  if (fragment_compiler_ == NULL) {
+      DLOG(ERROR) << "Could not create fragment shader translator.";
+      Destroy();
+      return false;
+  }
+
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 
   return true;
 }
 
 bool GLES2DecoderImpl::GenBuffersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetBufferInfo(client_ids[ii])) {
       return false;
     }
@@ skipping 305 matching lines @@
   }
 
   return true;
 }
 
 void GLES2DecoderImpl::SetSwapBuffersCallback(Callback0::Type* callback) {
   swap_buffers_callback_.reset(callback);
 }
 
 void GLES2DecoderImpl::Destroy() {
+#if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
+  if (vertex_compiler_ != NULL) {
+    ShDestruct(vertex_compiler_);
+    vertex_compiler_ = NULL;
+  }
+  if (fragment_compiler_ != NULL) {
+    ShDestruct(fragment_compiler_);
+    fragment_compiler_ = NULL;
+  }
+  ShFinalize();
+#endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER)
+
   if (context_.get()) {
     MakeCurrent();
 
     if (black_2d_texture_id_) {
       glDeleteTextures(1, &black_2d_texture_id_);
     }
     if (black_cube_texture_id_) {
       glDeleteTextures(1, &black_cube_texture_id_);
     }
     if (attrib_0_buffer_id_) {
@@ skipping 1382 matching lines @@
 void GLES2DecoderImpl::DoCompileShader(GLuint client_id) {
   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_TRANSLATE_SHADER)
-  ShHandle compiler = 0;
   if (use_shader_translator_) {
     int dbg_options = 0;
-    EShLanguage language = info->shader_type() == GL_VERTEX_SHADER ?
-        EShLangVertex : EShLangFragment;
-    TBuiltInResource resources;
-    resources.maxVertexAttribs = group_->max_vertex_attribs();
-    resources.maxVertexUniformVectors =
-        group_->max_vertex_uniform_vectors();
-    resources.maxVaryingVectors = group_->max_varying_vectors();
-    resources.maxVertexTextureImageUnits =
-        group_->max_vertex_texture_image_units();
-    resources.maxCombinedTextureImageUnits = group_->max_texture_units();
-    resources.maxTextureImageUnits = group_->max_texture_image_units();
-    resources.maxFragmentUniformVectors =
-        group_->max_fragment_uniform_vectors();
-    resources.maxDrawBuffers = 1;
-    compiler = ShConstructCompiler(language, dbg_options);
-    if (!ShCompile(compiler, &shader_src, 1, EShOptNone, &resources,
-                   dbg_options)) {
+    ShHandle compiler = info->shader_type() == GL_VERTEX_SHADER ?
+        vertex_compiler_ : fragment_compiler_;
+
+    if (!ShCompile(compiler, &shader_src, 1, EShOptNone, dbg_options)) {
       info->SetStatus(false, ShGetInfoLog(compiler));
-      ShDestruct(compiler);
       return;
     }
     shader_src = ShGetObjectCode(compiler);
   }
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 
   glShaderSource(info->service_id(), 1, &shader_src, NULL);
   glCompileShader(info->service_id());
   GLint status = GL_FALSE;
   glGetShaderiv(info->service_id(),  GL_COMPILE_STATUS, &status);
   if (status) {
     info->SetStatus(true, "");
   } else {
     GLint len = 0;
     glGetShaderiv(info->service_id(), GL_INFO_LOG_LENGTH, &len);
     scoped_array<char> temp(new char[len]);
     glGetShaderInfoLog(info->service_id(), len, &len, temp.get());
     info->SetStatus(false, std::string(temp.get(), len));
   }
-#ifdef GLES2_GPU_SERVICE_TRANSLATE_SHADER
-  if (use_shader_translator_) {
-    ShDestruct(compiler);
-  }
-#endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 };
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader, GLenum pname, GLint* params) {
   ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
       shader, "glGetShaderiv");
   if (!info) {
     return;
   }
   switch (pname) {
@@ skipping 1452 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