Prepare WebGL contexts for resource sharing with the compositor context.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 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 1293 matching lines @@
   bool use_shader_translator_;
   scoped_ptr<ShaderTranslator> vertex_translator_;
   scoped_ptr<ShaderTranslator> fragment_translator_;
 
   DisallowedExtensions disallowed_extensions_;
 
   // Cached from ContextGroup
   const Validators* validators_;
   FeatureInfo* feature_info_;
 
+  // Per GLES2DecoderImpl instance set of validators, which are used if
+  // a more constrained set of extensions is required for this particular
+  // context, wrt the shared ContextGroup.
+  scoped_ptr<FeatureInfo> local_feature_info_;
+
+  // Get the set of validators to use for API parameter verification.
+  const Validators* validators() const {
+    if (local_feature_info_.get())
+      return local_feature_info_->validators();
+    return validators_;
+  }
+
   // This indicates all the following texSubImage2D calls that are part of the
   // failed texImage2D call should be ignored.
   bool tex_image_2d_failed_;
 
   int frame_number_;
 
   bool has_arb_robustness_;
   GLenum reset_status_;
 
   bool needs_mac_nvidia_driver_workaround_;
@@ skipping 405 matching lines @@
   // Take ownership of the GLContext.
   context_ = context;
 
   if (!MakeCurrent()) {
     LOG(ERROR) << "GLES2DecoderImpl::Initialize failed because "
                << "MakeCurrent failed.";
     Destroy();
     return false;
   }
 
-  if (!group_->Initialize(disallowed_extensions, allowed_extensions)) {
+  // Initialization for a constrained set of extensions constructs a local
+  // set of validators, that override those of the sharing group.
+  if (0 == strcmp(allowed_extensions, "*")) {

[Ken Russell (switch to Gerrit), 2011/09/15 23:57:27]

Shouldn't this comparison be "0 != strcmp(...)"? We only want the local
FeatureInfo if the allowed extensions *aren't* "*".

[Jeff Timanus, 2011/09/16 15:00:17]

Yes!

Done.

+    local_feature_info_.reset(new FeatureInfo());
+    if (!local_feature_info_->Initialize(allowed_extensions)) {
+      LOG(ERROR) << "GpuScheduler::InitializeCommon failed because local "
+                 << "FeatureInfo overrides failed to initialize.";
+      Destroy();
+      return false;
+    }
+  }
+
+  // The shared group should always be initialized with all extensions.
+  // This ensures that all contexts will have access to all of the exentsions
+  // they may need.
+  if (!group_->Initialize(disallowed_extensions, "*")) {
     LOG(ERROR) << "GpuScheduler::InitializeCommon failed because group "
                << "failed to initialize.";
     Destroy();
     return false;
   }
 
   CHECK_GL_ERROR();
   disallowed_extensions_ = disallowed_extensions;
 
   vertex_attrib_manager_.Initialize(group_->max_vertex_attribs());
 
   util_.set_num_compressed_texture_formats(
-      validators_->compressed_texture_format.GetValues().size());
+      validators()->compressed_texture_format.GetValues().size());
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ skipping 181 matching lines @@
 
   if (!InitializeShaderTranslator()) {
     return false;
   }
 
   return true;
 }
 
 void GLES2DecoderImpl::UpdateCapabilities() {
   util_.set_num_compressed_texture_formats(
-      validators_->compressed_texture_format.GetValues().size());
+      validators()->compressed_texture_format.GetValues().size());
   util_.set_num_shader_binary_formats(
-      validators_->shader_binary_format.GetValues().size());
+      validators()->shader_binary_format.GetValues().size());
 }
 
 bool GLES2DecoderImpl::InitializeShaderTranslator() {
   // Re-check the state of use_shader_translator_ each time this is called.
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
       feature_info_->feature_flags().chromium_webglsl &&
       !use_shader_translator_) {
     use_shader_translator_ = true;
   }
   if (!use_shader_translator_) {
@@ skipping 1031 matching lines @@
       return true;
     case GL_STENCIL_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         glGetIntegerv(GL_STENCIL_BITS, &v);
         params[0] = BoundFramebufferHasStencilAttachment() ? v : 0;
       }
       return true;
     case GL_COMPRESSED_TEXTURE_FORMATS:
-      *num_written = validators_->compressed_texture_format.GetValues().size();
+      *num_written = validators()->compressed_texture_format.GetValues().size();
       if (params) {
         for (GLint ii = 0; ii < *num_written; ++ii) {
-          params[ii] = validators_->compressed_texture_format.GetValues()[ii];
+          params[ii] = validators()->compressed_texture_format.GetValues()[ii];
         }
       }
       return true;
     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
       *num_written = 1;
       if (params) {
-        *params = validators_->compressed_texture_format.GetValues().size();
+        *params = validators()->compressed_texture_format.GetValues().size();
       }
       return true;
     case GL_NUM_SHADER_BINARY_FORMATS:
       *num_written = 1;
       if (params) {
-        *params = validators_->shader_binary_format.GetValues().size();
+        *params = validators()->shader_binary_format.GetValues().size();
       }
       return true;
     case GL_SHADER_BINARY_FORMATS:
-      *num_written = validators_->shader_binary_format.GetValues().size();
+      *num_written = validators()->shader_binary_format.GetValues().size();
       if (params) {
         for (GLint ii = 0; ii <  *num_written; ++ii) {
-          params[ii] = validators_->shader_binary_format.GetValues()[ii];
+          params[ii] = validators()->shader_binary_format.GetValues()[ii];
         }
       }
       return true;
     case GL_SHADER_COMPILER:
       *num_written = 1;
       if (params) {
         *params = GL_TRUE;
       }
       return true;
     case GL_ARRAY_BUFFER_BINDING:
@@ skipping 1350 matching lines @@
   // settings and passing GL_FIXED to it will not work.
   glBindBuffer(GL_ARRAY_BUFFER,
                bound_array_buffer_ ? bound_array_buffer_->service_id() : 0);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArrays(
     uint32 immediate_data_size, const gles2::DrawArrays& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   GLint first = static_cast<GLint>(c.first);
   GLsizei count = static_cast<GLsizei>(c.count);
-  if (!validators_->draw_mode.IsValid(mode)) {
+  if (!validators()->draw_mode.IsValid(mode)) {
     SetGLError(GL_INVALID_ENUM, "glDrawArrays: mode GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArrays: count < 0");
     return error::kNoError;
   }
   if (!CheckFramebufferComplete("glDrawArrays")) {
     return error::kNoError;
   }
@@ skipping 48 matching lines @@
   GLenum type = c.type;
   int32 offset = c.index_offset;
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawElements: count < 0");
     return error::kNoError;
   }
   if (offset < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawElements: offset < 0");
     return error::kNoError;
   }
-  if (!validators_->draw_mode.IsValid(mode)) {
+  if (!validators()->draw_mode.IsValid(mode)) {
     SetGLError(GL_INVALID_ENUM, "glDrawElements: mode GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->index_type.IsValid(type)) {
+  if (!validators()->index_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glDrawElements: type GL_INVALID_ENUM");
     return error::kNoError;
   }
 
   if (!CheckFramebufferComplete("glDrawElements")) {
     return error::kNoError;
   }
 
   if (count == 0) {
     return error::kNoError;
@@ skipping 527 matching lines @@
     return error::kNoError;
   }
 
   GLuint indx = c.indx;
   GLint size = c.size;
   GLenum type = c.type;
   GLboolean normalized = c.normalized;
   GLsizei stride = c.stride;
   GLsizei offset = c.offset;
   const void* ptr = reinterpret_cast<const void*>(offset);
-  if (!validators_->vertex_attrib_type.IsValid(type)) {
+  if (!validators()->vertex_attrib_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM,
                "glVertexAttribPointer: type GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->vertex_attrib_size.IsValid(size)) {
+  if (!validators()->vertex_attrib_size.IsValid(size)) {
     SetGLError(GL_INVALID_VALUE,
                "glVertexAttribPointer: size GL_INVALID_VALUE");
     return error::kNoError;
   }
   if (indx >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttribPointer: index out of range");
     return error::kNoError;
   }
   if (stride < 0) {
     SetGLError(GL_INVALID_VALUE,
@@ skipping 56 matching lines @@
     return error::kOutOfBounds;
   }
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   Result* result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!pixels || !result) {
     return error::kOutOfBounds;
   }
 
-  if (!validators_->read_pixel_format.IsValid(format)) {
+  if (!validators()->read_pixel_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glReadPixels: format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->pixel_type.IsValid(type)) {
+  if (!validators()->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glReadPixels: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   CopyRealGLErrorsToWrapper();
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
@@ skipping 111 matching lines @@
     }
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePixelStorei(
     uint32 immediate_data_size, const gles2::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
-  if (!validators_->pixel_store.IsValid(pname)) {
+  if (!validators()->pixel_store.IsValid(pname)) {
     SetGLError(GL_INVALID_ENUM, "glPixelStorei: pname GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->pixel_store_alignment.IsValid(param)) {
+  if (!validators()->pixel_store_alignment.IsValid(param)) {
     SetGLError(GL_INVALID_VALUE, "glPixelSTore: param GL_INVALID_VALUE");
     return error::kNoError;
   }
   glPixelStorei(pname, param);
   switch (pname) {
   case GL_PACK_ALIGNMENT:
       pack_alignment_ = param;
       break;
   case GL_UNPACK_ALIGNMENT:
       unpack_alignment_ = param;
@@ skipping 135 matching lines @@
   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 (!validators_->string_type.IsValid(name)) {
+  if (!validators()->string_type.IsValid(name)) {
     SetGLError(GL_INVALID_ENUM, "glGetString: name GL_INVALID_ENUM");
     return error::kNoError;
   }
   const char* gl_str = reinterpret_cast<const char*>(glGetString(name));
   const char* str = NULL;
   switch (name) {
     case GL_VERSION:
       str = "OpenGL ES 2.0 Chromium";
       break;
     case GL_SHADING_LANGUAGE_VERSION:
       str = "OpenGL ES GLSL ES 1.0 Chromium";
       break;
     case GL_EXTENSIONS:
       str = feature_info_->extensions().c_str();
       break;
     default:
       str = gl_str;
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {
-  if (!validators_->buffer_target.IsValid(target)) {
+  if (!validators()->buffer_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glBufferData: target GL_INVALID_ENUM");
     return;
   }
-  if (!validators_->buffer_usage.IsValid(usage)) {
+  if (!validators()->buffer_usage.IsValid(usage)) {
     SetGLError(GL_INVALID_ENUM, "glBufferData: usage GL_INVALID_ENUM");
     return;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData: size < 0");
     return;
   }
   BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glBufferData: unknown buffer");
@@ skipping 77 matching lines @@
 error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLsizei image_size,
   const void* data) {
   // TODO(gman): Validate image_size is correct for width, height and format.
-  if (!validators_->texture_target.IsValid(target)) {
+  if (!validators()->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM,
                "glCompressedTexImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->compressed_texture_format.IsValid(
+  if (!validators()->compressed_texture_format.IsValid(
       internal_format)) {
     SetGLError(GL_INVALID_ENUM,
                "glCompressedTexImage2D: internal_format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(
         feature_info_, target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D: dimensions out of range");
@@ skipping 85 matching lines @@
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   Bucket* bucket = GetBucket(c.bucket_id);
   uint32 data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
-  if (!validators_->texture_target.IsValid(target)) {
+  if (!validators()->texture_target.IsValid(target)) {
     SetGLError(
         GL_INVALID_ENUM, "glCompressedTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->compressed_texture_format.IsValid(format)) {
+  if (!validators()->compressed_texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM,
                "glCompressedTexSubImage2D: format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: height < 0");
@@ skipping 12 matching lines @@
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLenum format,
   GLenum type,
   const void* pixels,
   uint32 pixels_size) {
-  if (!validators_->texture_target.IsValid(target)) {
+  if (!validators()->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->texture_format.IsValid(internal_format)) {
+  if (!validators()->texture_format.IsValid(internal_format)) {
     SetGLError(GL_INVALID_ENUM,
                "glTexImage2D: internal_format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->texture_format.IsValid(format)) {
+  if (!validators()->texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glTexImage2D: format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->pixel_type.IsValid(type)) {
+  if (!validators()->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glTexImage2D: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (format != internal_format) {
     SetGLError(GL_INVALID_OPERATION, "glTexImage2D: format != internalFormat");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(
         feature_info_, target, level, width, height, 1) ||
       border != 0) {
@@ skipping 400 matching lines @@
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_, &data_size)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
-  if (!validators_->texture_target.IsValid(target)) {
+  if (!validators()->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: height < 0");
     return error::kNoError;
   }
-  if (!validators_->texture_format.IsValid(format)) {
+  if (!validators()->texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->pixel_type.IsValid(type)) {
+  if (!validators()->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (pixels == NULL) {
     return error::kOutOfBounds;
   }
   DoTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
   return error::kNoError;
 }
@@ skipping 12 matching lines @@
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_, &data_size)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
-  if (!validators_->texture_target.IsValid(target)) {
+  if (!validators()->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: height < 0");
     return error::kNoError;
   }
-  if (!validators_->texture_format.IsValid(format)) {
+  if (!validators()->texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: format GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->pixel_type.IsValid(type)) {
+  if (!validators()->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (pixels == NULL) {
     return error::kOutOfBounds;
   }
   DoTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
     uint32 immediate_data_size, const gles2::GetVertexAttribPointerv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef gles2::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
-  if (!validators_->vertex_pointer.IsValid(pname)) {
+  if (!validators()->vertex_pointer.IsValid(pname)) {
     SetGLError(GL_INVALID_ENUM,
                "glGetVertexAttribPointerv: pname GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetVertexAttribPointerv: index out of range.");
     return error::kNoError;
   }
   result->SetNumResults(1);
@@ skipping 112 matching lines @@
   typedef gles2::GetShaderPrecisionFormat::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->success != 0) {
     return error::kInvalidArguments;
   }
-  if (!validators_->shader_type.IsValid(shader_type)) {
+  if (!validators()->shader_type.IsValid(shader_type)) {
     SetGLError(GL_INVALID_ENUM,
                "glGetShaderPrecisionFormat: shader_type GL_INVALID_ENUM");
     return error::kNoError;
   }
-  if (!validators_->shader_precision.IsValid(precision_type)) {
+  if (!validators()->shader_precision.IsValid(precision_type)) {
     SetGLError(GL_INVALID_ENUM,
                "glGetShaderPrecisionFormat: precision_type GL_INVALID_ENUM");
     return error::kNoError;
   }
 
   result->success = 1;  // true
   switch (precision_type) {
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
@@ skipping 287 matching lines @@
   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_support_fixed_attribs") == 0) {
     buffer_manager()->set_allow_buffers_on_multiple_targets(true);
     // TODO(gman): decide how to remove the need for this const_cast.
-    // I could make validators_ non const but that seems bad as this is the only
+    // I could make validators() non const but that seems bad as this is the only
     // place it is needed. I could make some special friend class of validators
     // just to allow this to set them. That seems silly. I could refactor this
     // code to use the extension mechanism or the initialization attributes to
     // turn this feature on. Given that the only real point of this is to make
     // the conformance tests pass and given that there is lots of real work that
     // needs to be done it seems like refactoring for one to one of those
     // methods is a very low priority.
-    const_cast<Validators*>(validators_)->vertex_attrib_type.AddValue(GL_FIXED);
+    const_cast<Validators*>(validators())->vertex_attrib_type.AddValue(
+        GL_FIXED);
   } else {
     return error::kNoError;
   }
 
   *result = 1;  // true.
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
     uint32 immediate_data_size,
@@ skipping 159 matching lines @@
   return false;
 }
 
 // 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