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 29 matching lines @@
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface.h"
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
 namespace gpu {
 namespace gles2 {
 
+namespace {
+static const char kOESDerivativeExtension[] = "GL_OES_standard_derivatives";
+}
+
 class GLES2DecoderImpl;
 
 // Check that certain assumptions the code makes are true. There are places in
 // the code where shared memory is passed direclty to GL. Example, glUniformiv,
 // glShaderSource. The command buffer code assumes GLint and GLsizei (and maybe
 // a few others) are 32bits. If they are not 32bits the code will have to change
 // to call those GL functions with service side memory and then copy the results
 // to shared memory, converting the sizes.
 COMPILE_ASSERT(sizeof(GLint) == sizeof(uint32),  // NOLINT
                GLint_not_same_size_as_uint32);
@@ skipping 1257 matching lines @@
   bool tex_image_2d_failed_;
 
   int frame_number_;
 
   bool has_arb_robustness_;
   GLenum reset_status_;
 
   bool needs_mac_nvidia_driver_workaround_;
   bool needs_glsl_built_in_function_emulation_;
 
+  // These flags are used to override the state of the shared feature_info_
+  // member.  Because the same FeatureInfo instance may be shared among many
+  // contexts, the assumptions on the availablity of extensions in WebGL
+  // contexts may be broken.  These flags override the shared state to preserve
+  // WebGL semantics.
+  bool force_webgl_glsl_validation_;
+  bool derivatives_explicitly_enabled_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   decoder_->ClearRealGLErrors();
@@ skipping 340 matching lines @@
       bufferdata_faster_than_buffersubdata_(true),
       current_decoder_error_(error::kNoError),
       use_shader_translator_(true),
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()),
       tex_image_2d_failed_(false),
       frame_number_(0),
       has_arb_robustness_(false),
       reset_status_(GL_NO_ERROR),
       needs_mac_nvidia_driver_workaround_(false),
-      needs_glsl_built_in_function_emulation_(false) {
+      needs_glsl_built_in_function_emulation_(false),
+      force_webgl_glsl_validation_(false),
+      derivatives_explicitly_enabled_(false) {
   DCHECK(group);
 
   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 used for WebGL even when running on EGL
   // because additional restrictions are needed (like only enabling
   // GL_OES_standard_derivatives on demand).  It is used for the unit
   // tests because
   // GLES2DecoderWithShaderTest.GetShaderInfoLogValidArgs passes the
   // empty string to CompileShader and this is not a valid shader.
   // TODO(apatrick): fix this test.
   if ((gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
-       !feature_info_->feature_flags().chromium_webglsl) ||
+       !feature_info_->feature_flags().chromium_webglsl &&
+       !force_webgl_glsl_validation_) ||
       gfx::GetGLImplementation() == gfx::kGLImplementationMockGL) {
     use_shader_translator_ = false;
   }
 
   // TODO(gman): Consider setting these based on GPU and/or driver.
   if (IsAngle()) {
     teximage2d_faster_than_texsubimage2d_ = false;
     bufferdata_faster_than_buffersubdata_ = false;
   }
 }
@@ skipping 248 matching lines @@
 void GLES2DecoderImpl::UpdateCapabilities() {
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
   util_.set_num_shader_binary_formats(
       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 &&
+      (feature_info_->feature_flags().chromium_webglsl ||
+       force_webgl_glsl_validation_) &&
       !use_shader_translator_) {
     use_shader_translator_ = true;
   }
   if (!use_shader_translator_) {
     return true;
   }
   ShBuiltInResources resources;
   ShInitBuiltInResources(&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;
-  resources.OES_standard_derivatives =
-      feature_info_->feature_flags().oes_standard_derivatives ? 1 : 0;
+
+  if (force_webgl_glsl_validation_) {
+    resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
+  } else {
+    resources.OES_standard_derivatives =
+        feature_info_->feature_flags().oes_standard_derivatives ? 1 : 0;
+  }
+
   vertex_translator_.reset(new ShaderTranslator);
-  ShShaderSpec shader_spec = feature_info_->feature_flags().chromium_webglsl ?
-      SH_WEBGL_SPEC : SH_GLES2_SPEC;
+  ShShaderSpec shader_spec = force_webgl_glsl_validation_ ||
+      feature_info_->feature_flags().chromium_webglsl ?
+          SH_WEBGL_SPEC : SH_GLES2_SPEC;
   ShaderTranslatorInterface::GlslImplementationType implementation_type =
       gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 ?
           ShaderTranslatorInterface::kGlslES : ShaderTranslatorInterface::kGlsl;
   ShaderTranslatorInterface::GlslBuiltInFunctionBehavior function_behavior =
       needs_glsl_built_in_function_emulation_ ?
           ShaderTranslatorInterface::kGlslBuiltInFunctionEmulated :
           ShaderTranslatorInterface::kGlslBuiltInFunctionOriginal;
   if (!vertex_translator_->Init(
           SH_VERTEX_SHADER, shader_spec, &resources,
           implementation_type, function_behavior)) {
@@ skipping 3455 matching lines @@
 
 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)) {
     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;
+  std::string extensions;
   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();
+      {
+        // For WebGL contexts, strip out the OES derivatives extension if it has
+        // not been enabled.

[greggman, 2011/09/29 22:15:07]

Is this necessary? 

It seems like the model we want is

1) WebGL (which is implemented in WebKit) thinks it's running on top of OpenGL
ES 2.0
2) In WebKit (ie, Safari and Chrome) it will always see the string
"GL_OES_stardard_derivatives"
3) WebGL would normally do its own GLSL validation, rejecting shaders that
attempt to use GL_OES_standard_derivatives
4) in Chrome, we want to add the option to tell the command buffer to do that
validation for WebGL since it's already doing some validation.

So, no reason to pull out GL_OES_standard_derivatives here

Instead, make it possible for WebGL to request that validation.

I would suggest that calling glEnableFeatureCHROMIUM with
"webgl_enable_glsl_webgl_validation" should set flags to make glsl validation as
strict as possible and something like
"webgl_enable_glsl_oes_standard_derivatives" should relax one that one
restriction.

+        if (force_webgl_glsl_validation_ &&
+            !derivatives_explicitly_enabled_) {
+          extensions = feature_info_->extensions();
+          size_t offset = extensions.find(kOESDerivativeExtension);
+          if (std::string::npos != offset) {
+            extensions.replace(offset,
+                               offset + arraysize(kOESDerivativeExtension),
+                               std::string());
+          }
+          str = extensions.c_str();
+        } else {
+          str = feature_info_->extensions().c_str();
+        }
+
+      }
       break;
     default:
       str = gl_str;
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
@@ skipping 1215 matching lines @@
     // 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
     // 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);
+  } else if (feature_str.compare("webgl_enable_glsl_webgl_validation") == 0) {
+    force_webgl_glsl_validation_ = true;
+    InitializeShaderTranslator();
   } else {
     return error::kNoError;
   }
 
   *result = 1;  // true.
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
     uint32 immediate_data_size,
@@ skipping 13 matching lines @@
     return error::kInvalidArguments;
   }
 
   bool std_derivatives_enabled =
       feature_info_->feature_flags().oes_standard_derivatives;
   bool webglsl_enabled =
       feature_info_->feature_flags().chromium_webglsl;
 
   feature_info_->AddFeatures(feature_str.c_str());
 
+  bool initialization_required = false;
+  if (force_webgl_glsl_validation_ && !derivatives_explicitly_enabled_) {
+    size_t derivatives_offset = feature_str.find(kOESDerivativeExtension);
+    if (std::string::npos != derivatives_offset) {
+      derivatives_explicitly_enabled_ = true;
+      initialization_required = true;
+    }
+  }
+
   // If we just enabled a feature which affects the shader translator,
   // we may need to re-initialize it.
   if (std_derivatives_enabled !=
           feature_info_->feature_flags().oes_standard_derivatives ||
       webglsl_enabled !=
-          feature_info_->feature_flags().chromium_webglsl) {
+          feature_info_->feature_flags().chromium_webglsl ||
+      initialization_required) {
     InitializeShaderTranslator();
   }
 
   UpdateCapabilities();
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetMultipleIntegervCHROMIUM(
     uint32 immediate_data_size, const gles2::GetMultipleIntegervCHROMIUM& c) {
@@ skipping 120 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