Validate fbo color image format and fragment shader output variable type.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 1348 matching lines @@
   // -1. If the current program is not valid generates the appropriate GL
   // error. Returns true if the current program is in a usable state and
   // location is not -1.
   bool CheckCurrentProgramForUniform(GLint location, const char* function_name);
 
   // Checks if the current program samples a texture that is also the color
   // image of the current bound framebuffer, i.e., the source and destination
   // of the draw operation are the same.
   bool CheckDrawingFeedbackLoops();
 
+  // Checks if a draw buffer's format and its corresponding fragment shader
+  // output's type are compatible, i.e., a signed integer typed variable is
+  // incompatible with a float or unsigned integer buffer.
+  // If incompaticle, generates an INVALID_OPERATION to avoid undefined buffer
+  // contents and return false.
+  // Otherwise, filter out the draw buffers that are not written to but are not
+  // NONE through DrawBuffers, to be on the safe side; set |adjusted| to true
+  // if such adjustments happen. Return true.
+  bool ValidateAndAdjustDrawBuffers(const char* function_name, bool* adjusted);
+
   // Checks if |api_type| is valid for the given uniform
   // If the api type is not valid generates the appropriate GL
   // error. Returns true if |api_type| is valid for the uniform
   bool CheckUniformForApiType(const Program::UniformInfo* info,
                               const char* function_name,
                               Program::UniformApiType api_type);
 
   // Gets the type of a uniform for a location in the current program. Sets GL
   // errors if the current program is not valid. Returns true if the current
   // program is valid and the location exists. Adjusts count so it
@@ skipping 5710 matching lines @@
       // TODO(zmo): There is no guarantee that an FBO that is complete on the
       // READ attachment will be complete as a DRAW attachment.
       glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, framebuffer->service_id());
     }
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
     glClear(clear_bits);
   }
 
   if (cleared_int_renderbuffers || clear_bits) {
     if (reset_draw_buffers)
-      framebuffer->RestoreDrawBuffersAfterClear();
+      framebuffer->RestoreDrawBuffers();
     RestoreClearState();
     if (target == GL_READ_FRAMEBUFFER && draw_framebuffer != framebuffer) {
       GLuint service_id = draw_framebuffer ? draw_framebuffer->service_id() :
                                              GetBackbufferServiceId();
       glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, service_id);
     }
   }
 
   framebuffer_manager()->MarkAttachmentsAsCleared(
       framebuffer, renderbuffer_manager(), texture_manager());
@@ skipping 909 matching lines @@
       TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
       TextureRef* texture_ref =
           texture_unit.GetInfoForSamplerType(uniform_info->type).get();
       if (attachment->IsTexture(texture_ref))
         return true;
     }
   }
   return false;
 }
 
+bool GLES2DecoderImpl::ValidateAndAdjustDrawBuffers(
+    const char* function_name, bool* adjusted) {
+  bool validation = true;
+  bool my_adjusted = false;
+  switch (feature_info_->context_type()) {
+    case CONTEXT_TYPE_OPENGLES2:
+    case CONTEXT_TYPE_WEBGL1:
+      // Int and unsigned int formats are not available in ES2/WebGL1.
+      validation = false;
+      break;
+    default:
+      break;
+  }
+  Framebuffer* framebuffer = framebuffer_state_.bound_draw_framebuffer.get();
+  if (!state_.current_program.get() || !framebuffer) {
+    return true;
+  }
+  const std::vector<ShaderVariableBaseType>& fragment_output_base_types =
+      state_.current_program->GetFragmentOutputBaseTypes();
+  const std::vector<ShaderVariableBaseType>& color_attachment_base_types =
+      framebuffer->GetColorAttachmentBaseTypes();
+  DCHECK_EQ(fragment_output_base_types.size(),
+            color_attachment_base_types.size());
+  size_t count = color_attachment_base_types.size();
+  std::unique_ptr<GLenum[]> adjusted_draw_buffers(new GLenum[count]);
+  for (size_t ii = 0; ii < count; ++ii) {
+    adjusted_draw_buffers[ii] =
+        framebuffer->GetDrawBuffer(GL_DRAW_BUFFER0 + ii);
+    if (adjusted_draw_buffers[ii] == GL_NONE)
+      continue;
+    if (fragment_output_base_types[ii] == SHADER_VARIABLE_UNDEFINED_TYPE) {
+      adjusted_draw_buffers[ii] = GL_NONE;

[Corentin Wallez, 2016/07/13 14:50:07]

This looks like it will be doing an allocation for every draw call in WebGL2.
Can we avoid this cost, for example by lazy allocating adjusted_draw_buffers or
using dirty bits?

+      my_adjusted = true;
+      continue;
+    }
+    if (!validation)
+      continue;
+    if (color_attachment_base_types[ii] == SHADER_VARIABLE_UNDEFINED_TYPE)
+      continue;
+    if (fragment_output_base_types[ii] != color_attachment_base_types[ii]) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+          "buffer format and fragment output variable type incompatible");
+      return false;
+    }
+  }
+  if (my_adjusted) {
+    glDrawBuffersARB(count, adjusted_draw_buffers.get());
+  }
+  *adjusted = my_adjusted;
+  return true;
+}
+
 bool GLES2DecoderImpl::CheckUniformForApiType(
     const Program::UniformInfo* info,
     const char* function_name,
     Program::UniformApiType api_type) {
   DCHECK(info);
   if ((api_type & info->accepts_api_type) == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "wrong uniform function for type");
     return false;
   }
@@ skipping 1007 matching lines @@
     if (!SimulateAttrib0(
         function_name, max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(
         function_name, max_vertex_accessed, &simulated_fixed_attribs,
         primcount)) {
       bool textures_set = !PrepareTexturesForRender();
       ApplyDirtyState();
+      bool adjusted = false;
+      if (!ValidateAndAdjustDrawBuffers(function_name, &adjusted)) {
+        return error::kNoError;
+      }
       if (!instanced) {
         glDrawArrays(mode, first, count);
       } else {
         glDrawArraysInstancedANGLE(mode, first, count, primcount);
       }
+      if (adjusted) {
+        DCHECK(framebuffer_state_.bound_draw_framebuffer.get());
+        framebuffer_state_.bound_draw_framebuffer->RestoreDrawBuffers();
+      }
       if (textures_set) {
         RestoreStateForTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
       // We don't have to restore attrib 0 generic data at the end of this
       // function even if it is simulated. This is because we will simulate
@@ skipping 116 matching lines @@
       ApplyDirtyState();
       // TODO(gman): Refactor to hide these details in BufferManager or
       // VertexAttribManager.
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       bool used_client_side_array = false;
       if (element_array_buffer->IsClientSideArray()) {
         used_client_side_array = true;
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
         indices = element_array_buffer->GetRange(offset, 0);
       }
-
+      bool adjusted = false;
+      if (!ValidateAndAdjustDrawBuffers(function_name, &adjusted)) {
+        return error::kNoError;
+      }
       if (state_.enable_flags.primitive_restart_fixed_index &&
           feature_info_->feature_flags().
               emulate_primitive_restart_fixed_index) {
         glEnable(GL_PRIMITIVE_RESTART);
         buffer_manager()->SetPrimitiveRestartFixedIndexIfNecessary(type);
       }
-
       if (!instanced) {
         glDrawElements(mode, count, type, indices);
       } else {
         glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
       }
       if (state_.enable_flags.primitive_restart_fixed_index &&
           feature_info_->feature_flags().
               emulate_primitive_restart_fixed_index) {
         glDisable(GL_PRIMITIVE_RESTART);
       }
-
+      if (adjusted) {
+        DCHECK(framebuffer_state_.bound_draw_framebuffer.get());
+        framebuffer_state_.bound_draw_framebuffer->RestoreDrawBuffers();
+      }
       if (used_client_side_array) {
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
                      element_array_buffer->service_id());
       }
-
       if (textures_set) {
         RestoreStateForTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
       // We don't have to restore attrib 0 generic data at the end of this
       // function even if it is simulated. This is because we will simulate
@@ skipping 7875 matching lines @@
 }
 
 // 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu