Update the GLSL translator code to use the correct constants

and save the error log so it can be passed back through GL
calls.

This also links with the GLSL translator always

TEST=conformance tests
BUG=none

Review URL: http://codereview.chromium.org/2096008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@47578 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 223 insertions, 84 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 750dfdb..acea9d3 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1214,7 +1214,8 @@ _FUNCTION_INFO = {
     'type': 'STRn',
     'get_len_func': 'glGetShaderiv',
     'get_len_enum': 'GL_INFO_LOG_LENGTH',
-    },
+    'unit_test': False,
+  },
   'GetShaderPrecisionFormat': {
     'type': 'Custom',
     'immediate': False,
@@ -3749,7 +3750,7 @@ TEST_F(%(test_name)s, %(name)sValidArgs) {
     if get_len_func[0:2] == 'gl':
       sub['expect_len_code'] = (
         "  EXPECT_CALL(*gl_, %s(%s, %s, _))\n"
-        "      .WillOnce(SetArgumentPointee<2>(strlen(kInfo)));") % (
+        "      .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1));") % (
             get_len_func[2:], id_name, get_len_enum)
     self.WriteValidUnitTest(func, file, valid_test, sub)
 
diff --git a/gpu/command_buffer/service/context_group.cc b/gpu/command_buffer/service/context_group.cc
index 7a62c72..71b796c 100644
--- a/gpu/command_buffer/service/context_group.cc
+++ b/gpu/command_buffer/service/context_group.cc
@@ -17,12 +17,23 @@ namespace gles2 {
 ContextGroup::ContextGroup()
     : initialized_(false),
       max_vertex_attribs_(0u),
-      max_texture_units_(0u) {
+      max_texture_units_(0u),
+      max_texture_image_units_(0u),
+      max_vertex_texture_image_units_(0u),
+      max_fragment_uniform_vectors_(0u),
+      max_varying_vectors_(0u),
+      max_vertex_uniform_vectors_(0u) {
 }
 
 ContextGroup::~ContextGroup() {
 }
 
+static void GetIntegerv(GLenum pname, uint32* var) {
+  GLint value = 0;
+  glGetIntegerv(pname, &value);
+  *var = value;
+}
+
 bool ContextGroup::Initialize() {
   if (initialized_) {
     return true;
@@ -35,14 +46,11 @@ bool ContextGroup::Initialize() {
   program_manager_.reset(new ProgramManager());
 
   // Lookup GL things we need to know.
-  GLint value;
-  glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value);
-  max_vertex_attribs_ = value;
+  GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs_);
   const GLuint kGLES2RequiredMiniumumVertexAttribs = 8u;
   DCHECK_GE(max_vertex_attribs_, kGLES2RequiredMiniumumVertexAttribs);
 
-  glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &value);
-  max_texture_units_ = value;
+  GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_texture_units_);
   const GLuint kGLES2RequiredMiniumumTextureUnits = 8u;
   DCHECK_GE(max_texture_units_, kGLES2RequiredMiniumumTextureUnits);
 
@@ -52,6 +60,29 @@ bool ContextGroup::Initialize() {
   glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &max_cube_map_texture_size);
   texture_manager_.reset(new TextureManager(max_texture_size,
                                             max_cube_map_texture_size));
+
+  GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_image_units_);
+  GetIntegerv(
+      GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &max_vertex_texture_image_units_);
+
+#if defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
+
+  GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &max_fragment_uniform_vectors_);
+  GetIntegerv(GL_MAX_VARYING_VECTORS, &max_varying_vectors_);
+  GetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &max_vertex_uniform_vectors_);
+
+#else  // !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
+
+  GetIntegerv(
+      GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max_fragment_uniform_vectors_);
+  max_fragment_uniform_vectors_ /= 4;
+  GetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_vectors_);
+  max_varying_vectors_ /= 4;
+  GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &max_vertex_uniform_vectors_);
+  max_vertex_uniform_vectors_ /= 4;
+
+#endif  // !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
+
   initialized_ = true;
   return true;
 }
diff --git a/gpu/command_buffer/service/context_group.h b/gpu/command_buffer/service/context_group.h
index 2b0bf46..12fa7b6 100644
--- a/gpu/command_buffer/service/context_group.h
+++ b/gpu/command_buffer/service/context_group.h
@@ -42,6 +42,26 @@ class ContextGroup {
     return max_texture_units_;
   }
 
+  uint32 max_texture_image_units() const {
+    return max_texture_image_units_;
+  }
+
+  uint32 max_vertex_texture_image_units() const {
+    return max_vertex_texture_image_units_;
+  }
+
+  uint32 max_fragment_uniform_vectors() const {
+    return max_fragment_uniform_vectors_;
+  }
+
+  uint32 max_varying_vectors() const {
+    return max_varying_vectors_;
+  }
+
+  uint32 max_vertex_uniform_vectors() const {
+    return max_vertex_uniform_vectors_;
+  }
+
   BufferManager* buffer_manager() const {
     return buffer_manager_.get();
   }
@@ -73,8 +93,12 @@ class ContextGroup {
   bool initialized_;
 
   uint32 max_vertex_attribs_;
-
   uint32 max_texture_units_;
+  uint32 max_texture_image_units_;
+  uint32 max_vertex_texture_image_units_;
+  uint32 max_fragment_uniform_vectors_;
+  uint32 max_varying_vectors_;
+  uint32 max_vertex_uniform_vectors_;
 
   scoped_ptr<BufferManager> buffer_manager_;
 
diff --git a/gpu/command_buffer/service/context_group_unittest.cc b/gpu/command_buffer/service/context_group_unittest.cc
index d46bec6..c997f7a 100644
--- a/gpu/command_buffer/service/context_group_unittest.cc
+++ b/gpu/command_buffer/service/context_group_unittest.cc
@@ -27,6 +27,11 @@ TEST_F(ContextGroupTest, Basic) {
   // Test it starts off uninitialized.
   EXPECT_EQ(0u, group_.max_vertex_attribs());
   EXPECT_EQ(0u, group_.max_texture_units());
+  EXPECT_EQ(0u, group_.max_texture_image_units());
+  EXPECT_EQ(0u, group_.max_vertex_texture_image_units());
+  EXPECT_EQ(0u, group_.max_fragment_uniform_vectors());
+  EXPECT_EQ(0u, group_.max_varying_vectors());
+  EXPECT_EQ(0u, group_.max_vertex_uniform_vectors());
   EXPECT_TRUE(group_.buffer_manager() == NULL);
   EXPECT_TRUE(group_.framebuffer_manager() == NULL);
   EXPECT_TRUE(group_.renderbuffer_manager() == NULL);
diff --git a/gpu/command_buffer/service/gl_utils.h b/gpu/command_buffer/service/gl_utils.h
index de2f044..c7cf11b 100644
--- a/gpu/command_buffer/service/gl_utils.h
+++ b/gpu/command_buffer/service/gl_utils.h
@@ -12,9 +12,15 @@
 
 #if defined(UNIT_TEST)
   #include "gpu/command_buffer/service/gl_mock.h"
+  // OpenGL constants not defined in OpenGL ES 2.0 needed when compiling
+  // unit tests. For native OpenGL ES 2.0 backend these are not used. For OpenGL
+  // backend these must be defined by the local system.
   #if !defined(GL_VERTEX_PROGRAM_POINT_SIZE)
     #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
   #endif
+  #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+  #define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+  #define GL_MAX_VARYING_FLOATS 0x8B4B
 #else
   #if defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
     #include <GLES2/gl2.h>  // NOLINT
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 3d68326..747e839 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -41,17 +41,6 @@
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
-#if defined(UNIT_TEST)
-
-// OpenGL constants not defined in OpenGL ES 2.0 needed when compiling
-// unit tests. For native OpenGL ES 2.0 backend these are not used. For OpenGL
-// backend these must be defined by the local system.
-#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
-#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
-#define GL_MAX_VARYING_FLOATS 0x8B4B
-
-#endif
-
 namespace gpu {
 namespace gles2 {
 
@@ -2203,22 +2192,19 @@ bool GLES2DecoderImpl::GetHelper(
     case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
       *num_written = 1;
       if (params) {
-        glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, params);
-        *params /= 4;
+        *params = group_->max_fragment_uniform_vectors();
       }
       return true;
     case GL_MAX_VARYING_VECTORS:
       *num_written = 1;
       if (params) {
-        glGetIntegerv(GL_MAX_VARYING_FLOATS, params);
-        *params /= 4;
+        *params = group_->max_varying_vectors();
       }
       return true;
     case GL_MAX_VERTEX_UNIFORM_VECTORS:
       *num_written = 1;
       if (params) {
-        glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, params);
-        *params /= 4;
+        *params = group_->max_vertex_uniform_vectors();
       }
       return true;
 #endif
@@ -3241,33 +3227,32 @@ void GLES2DecoderImpl::DoCompileShader(GLuint client_id) {
     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.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 = 8;
-    resources.maxFragmentUniformVectors = 16;
+    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)) {
-      // 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);
+      info->SetTranslationStatus(false, ShGetInfoLog(compiler));
       ShDestruct(compiler);
       return;
     }
+    info->SetTranslationStatus(true, "");
     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
   if (use_shader_translator_) {
@@ -3284,11 +3269,26 @@ void GLES2DecoderImpl::DoGetShaderiv(
   if (!info) {
     return;
   }
-  if (pname == GL_SHADER_SOURCE_LENGTH) {
-    *params = info->source().size();
-  } else {
-    glGetShaderiv(info->service_id(), pname, params);
+  switch (pname) {
+    case GL_SHADER_SOURCE_LENGTH:
+      *params = info->source().size();
+      return;
+    case GL_COMPILE_STATUS:
+      if (!info->translation_valid()) {
+        *params = GL_FALSE;
+        return;
+      }
+      break;
+    case GL_INFO_LOG_LENGTH:
+      if (!info->translation_valid()) {
+        *params = info->translation_log().size() + 1;
+        return;
+      }
+      break;
+    default:
+      break;
   }
+  glGetShaderiv(info->service_id(), pname, params);
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderSource(
@@ -3318,10 +3318,10 @@ error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
   }
   GLint len = 0;
   glGetProgramiv(info->service_id(), GL_INFO_LOG_LENGTH, &len);
-  bucket->SetSize(len + 1);
+  bucket->SetSize(len);
   glGetProgramInfoLog(
       info->service_id(),
-      len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
+      len, &len, bucket->GetDataAs<GLchar*>(0, len));
   return error::kNoError;
 }
 
@@ -3336,12 +3336,16 @@ error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
     bucket->SetSize(0);
     return error::kNoError;
   }
-  GLint len = 0;
-  glGetShaderiv(info->service_id(), GL_INFO_LOG_LENGTH, &len);
-  bucket->SetSize(len + 1);
-  glGetShaderInfoLog(
-      info->service_id(),
-      len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
+  if (!info->translation_valid()) {
+    bucket->SetFromString(info->translation_log());
+  } else {
+    GLint len = 0;
+    glGetShaderiv(info->service_id(), GL_INFO_LOG_LENGTH, &len);
+    bucket->SetSize(len);
+    glGetShaderInfoLog(
+        info->service_id(),
+        len, &len, bucket->GetDataAs<GLchar*>(0, len));
+  }
   return error::kNoError;
 }
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index 766dfae..a45c982 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -906,6 +906,40 @@ TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
+  const char* kInfo = "hello";
+  const uint32 kBucketId = 123;
+  CompileShader compile_cmd;
+  GetShaderInfoLog cmd;
+  EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
+  EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
+  EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _))
+      .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1))
+      .RetiresOnSaturation();
+  EXPECT_CALL(
+      *gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
+                      SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
+  compile_cmd.Init(client_shader_id_);
+  cmd.Init(client_shader_id_, kBucketId);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd));
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
+  ASSERT_TRUE(bucket != NULL);
+  EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
+  EXPECT_EQ(0, memcmp(bucket->GetData(0, bucket->size()), kInfo,
+                      bucket->size()));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
+  const uint32 kBucketId = 123;
+  GetShaderInfoLog cmd;
+  cmd.Init(kInvalidClientId, kBucketId);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest, CompileShaderValidArgs) {
   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
index 824c051..76000af 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
@@ -1486,7 +1486,7 @@ TEST_F(GLES2DecoderTest1, GetProgramInfoLogValidArgs) {
   const uint32 kBucketId = 123;
   SpecializedSetup<GetProgramInfoLog, 0>(true);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _))
-      .WillOnce(SetArgumentPointee<2>(strlen(kInfo)));
+      .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1));
   EXPECT_CALL(
       *gl_, GetProgramInfoLog(kServiceProgramId, strlen(kInfo) + 1, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
@@ -1623,37 +1623,7 @@ TEST_F(GLES2DecoderTest1, GetShaderivInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(0u, result->size);
 }
-
-TEST_F(GLES2DecoderTest1, GetShaderInfoLogValidArgs) {
-  const char* kInfo = "hello";
-  const uint32 kBucketId = 123;
-  SpecializedSetup<GetShaderInfoLog, 0>(true);
-  EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _))
-      .WillOnce(SetArgumentPointee<2>(strlen(kInfo)));
-  EXPECT_CALL(
-      *gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
-                      SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
-  GetShaderInfoLog cmd;
-  cmd.Init(client_shader_id_, kBucketId);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
-  ASSERT_TRUE(bucket != NULL);
-  EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
-  EXPECT_EQ(0, memcmp(bucket->GetData(0, bucket->size()), kInfo,
-                      bucket->size()));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_F(GLES2DecoderTest1, GetShaderInfoLogInvalidArgs) {
-  const uint32 kBucketId = 123;
-  EXPECT_CALL(*gl_, GetShaderInfoLog(_, _, _, _))
-      .Times(0);
-  GetShaderInfoLog cmd;
-  cmd.Init(kInvalidClientId, kBucketId);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
+// TODO(gman): GetShaderInfoLog
 // TODO(gman): GetShaderPrecisionFormat
 
 // TODO(gman): GetShaderSource
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index 33fbf54..a9cc632 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -45,6 +45,38 @@ void GLES2DecoderTestBase::SetUp() {
   EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, _))
       .WillOnce(SetArgumentPointee<1>(kMaxCubeMapTextureSize))
       .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxTextureImageUnits))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxVertexTextureImageUnits))
+      .RetiresOnSaturation();
+
+#if defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
+
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxFragmentUniformVectors * 4))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VARYING_VECTORS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxVaryingVectors * 4))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxVertexUniformVectors * 4))
+      .RetiresOnSaturation();
+
+#else  // !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
+
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxFragmentUniformVectors))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VARYING_FLOATS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxVaryingVectors))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, _))
+      .WillOnce(SetArgumentPointee<1>(kMaxVertexUniformVectors))
+      .RetiresOnSaturation();
+
+#endif  // !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
 
   EXPECT_CALL(*gl_, EnableVertexAttribArray(0))
       .Times(1)
@@ -309,6 +341,11 @@ const GLint GLES2DecoderTestBase::kMaxTextureSize;
 const GLint GLES2DecoderTestBase::kMaxCubeMapTextureSize;
 const GLint GLES2DecoderTestBase::kNumVertexAttribs;
 const GLint GLES2DecoderTestBase::kNumTextureUnits;
+const GLint GLES2DecoderTestBase::kMaxTextureImageUnits;
+const GLint GLES2DecoderTestBase::kMaxVertexTextureImageUnits;
+const GLint GLES2DecoderTestBase::kMaxFragmentUniformVectors;
+const GLint GLES2DecoderTestBase::kMaxVaryingVectors;
+const GLint GLES2DecoderTestBase::kMaxVertexUniformVectors;
 
 const GLuint GLES2DecoderTestBase::kServiceBlackTexture2dId;
 const GLuint GLES2DecoderTestBase::kServiceBlackTextureCubemapId;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
index f18b598..e4e7be2 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
@@ -42,6 +42,11 @@ class GLES2DecoderTestBase : public testing::Test {
   static const GLint kMaxCubeMapTextureSize = 256;
   static const GLint kNumVertexAttribs = 16;
   static const GLint kNumTextureUnits = 8;
+  static const GLint kMaxTextureImageUnits = 8;
+  static const GLint kMaxVertexTextureImageUnits = 2;
+  static const GLint kMaxFragmentUniformVectors = 16;
+  static const GLint kMaxVaryingVectors = 8;
+  static const GLint kMaxVertexUniformVectors = 128;
 
   static const GLuint kServiceBlackTexture2dId = 701;
   static const GLuint kServiceBlackTextureCubemapId = 702;
diff --git a/gpu/command_buffer/service/shader_manager.h b/gpu/command_buffer/service/shader_manager.h
index caf41b4..3391ff6 100644
--- a/gpu/command_buffer/service/shader_manager.h
+++ b/gpu/command_buffer/service/shader_manager.h
@@ -30,7 +30,8 @@ class ShaderManager {
 
     explicit ShaderInfo(GLuint service_id, GLenum shader_type)
         : service_id_(service_id),
-          shader_type_(shader_type) {
+          shader_type_(shader_type),
+          translation_valid_(true) {
     }
 
     void Update(const std::string& source) {
@@ -49,6 +50,19 @@ class ShaderManager {
       return source_;
     }
 
+    void SetTranslationStatus(bool valid, const std::string& log) {
+      translation_valid_ = valid;
+      translation_log_ = log;
+    }
+
+    const std::string& translation_log() const {
+      return translation_log_;
+    }
+
+    bool translation_valid() const {
+      return translation_valid_;
+    }
+
     bool IsDeleted() const {
       return service_id_ == 0;
     }
@@ -67,8 +81,14 @@ class ShaderManager {
     // Type of shader - GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.
     GLenum shader_type_;
 
+    // True if translation succeeded.
+    bool translation_valid_;
+
     // The shader source as passed to glShaderSource.
     std::string source_;
+
+    // The shader translation log.
+    std::string translation_log_;
   };
 
   ShaderManager() {
diff --git a/gpu/command_buffer/service/shader_manager_unittest.cc b/gpu/command_buffer/service/shader_manager_unittest.cc
index 70d733b..12ec9e4 100644
--- a/gpu/command_buffer/service/shader_manager_unittest.cc
+++ b/gpu/command_buffer/service/shader_manager_unittest.cc
@@ -37,6 +37,7 @@ TEST_F(ShaderManagerTest, Basic) {
   EXPECT_EQ(kService1Id, info1->service_id());
   // Check if the shader has correct type.
   EXPECT_EQ(kShader1Type, info1->shader_type());
+  EXPECT_EQ(true, info1->translation_valid());
   // Check we can set its source.
   info1->Update(kClient1Source);
   EXPECT_STREQ(kClient1Source.c_str(), info1->source().c_str());
diff --git a/gpu/gpu.gyp b/gpu/gpu.gyp
index b52d1fe..ef39e53 100644
--- a/gpu/gpu.gyp
+++ b/gpu/gpu.gyp
@@ -40,7 +40,6 @@
       'command_buffer/service/texture_manager.h',
       'command_buffer/service/texture_manager.cc',
     ],
-    'enable_shader_translation%': 0,
   },
   'targets': [
     {
@@ -270,7 +269,9 @@
             '../build/linux/system.gyp:gtk',
           ],
         }],
-        ['enable_shader_translation==1', {
+        # TODO(gman): Change this condition to be false if the backend is
+        # native OpenGL ES 2.0 and false if the backend is OpenGL.
+        ['1==1', {
           'defines': [
             'GLES2_GPU_SERVICE_TRANSLATE_SHADER',
           ],