[Command buffer] workaround the framebuffer completeness bug for Intel Mac

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 1280 matching lines @@
       GLint layer);
 
   // Check if a framebuffer meets our requirements.
   // Generates |gl_error| if the framebuffer is incomplete.
   bool CheckFramebufferValid(
       Framebuffer* framebuffer,
       GLenum target,
       GLenum gl_error,
       const char* func_name);
 
-  bool CheckBoundDrawFramebufferValid(const char* func_name);
+  bool CheckBoundDrawFramebufferValid(
+      const char* func_name,
+      bool may_need_workaround);

[Zhenyao Mo, 2016/11/16 03:27:27]

may_need_workaround should always be true.  i.e., we can just remove it.

   // Generates |gl_error| if the bound read fbo is incomplete.
-  bool CheckBoundReadFramebufferValid(const char* func_name, GLenum gl_error);
+  bool CheckBoundReadFramebufferValid(
+      const char* func_name,
+      GLenum gl_error,
+      bool may_need_workaround);

[Zhenyao Mo, 2016/11/16 03:27:27]

Same here, see my comments below.

   // This is only used by DoBlitFramebufferCHROMIUM which operates read/draw
   // framebuffer at the same time.
   bool CheckBoundFramebufferValid(const char* func_name);
 
   // Checks if the current program exists and is valid. If not generates the
   // appropriate GL error.  Returns true if the current program is in a usable
   // state.
   bool CheckCurrentProgram(const char* function_name);
 
   // Checks if the current program exists and is valid and that location is not
@@ skipping 110 matching lines @@
   // Wrapper for glBlitFramebufferCHROMIUM.
   void DoBlitFramebufferCHROMIUM(
       GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
       GLbitfield mask, GLenum filter);
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
+  // If the specified draw buffer have no image, return true.
+  // Otherwise, return false.
+  bool SpecifiedDrawBufferHasNoImage(GLint ii);
+
+  // A workaround to adjust read buffer and draw buffers to GL_NONE
+  // if the specified read buffer or draw buffers have missing images.
+  // Return false if read buffer has no image or all of the draw buffers
+  // have no image after adjustment. Then we can generate
+  // INVALID_OPERATION or return directly in the callers accordingly.
+  bool AdjustColorBufferAttachmentsIfNecessary(

[Zhenyao Mo, 2016/11/16 03:27:28]

It should really be AdjustReadBufferAndDrawBuffersIfNecessary().

Also, to be simple, you could always adjust read and draw, so no need for the
following two args.

+    bool read, bool draw);
+
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glClear*()
   error::Error DoClear(GLbitfield mask);
   void DoClearBufferiv(GLenum buffer,
                        GLint drawbuffer,
                        const volatile GLint* value);
   void DoClearBufferuiv(GLenum buffer,
                         GLint drawbuffer,
@@ skipping 2823 matching lines @@
   // Are all the attachments cleared?
   if (renderbuffer_manager()->HaveUnclearedRenderbuffers() ||
       texture_manager()->HaveUnclearedMips()) {
     if (!framebuffer->IsCleared()) {
       ClearUnclearedAttachments(target, framebuffer);
     }
   }
   return true;
 }
 
-bool GLES2DecoderImpl::CheckBoundDrawFramebufferValid(const char* func_name) {
+bool GLES2DecoderImpl::CheckBoundDrawFramebufferValid(
+    const char* func_name, bool may_need_workaround) {
+  if (may_need_workaround &&
+      workarounds().read_draw_buffers_missing_image &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true)) {
+      return false;
+    }
+  }
   GLenum target = features().chromium_framebuffer_multisample ?
       GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   bool valid = CheckFramebufferValid(
       framebuffer, target, GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
   if (valid && !features().chromium_framebuffer_multisample)
     OnUseFramebuffer();
   if (valid && feature_info_->feature_flags().desktop_srgb_support) {
     // If framebuffer contains sRGB images, then enable FRAMEBUFFER_SRGB.
     // Otherwise, disable FRAMEBUFFER_SRGB. Assume default fbo does not have
     // sRGB image.
     // In theory, we can just leave FRAMEBUFFER_SRGB on. However, many drivers
     // behave incorrectly when all images are linear encoding, they still apply
     // the sRGB conversion, but when at least one image is sRGB, then they
     // behave correctly.
     bool enable_framebuffer_srgb =
         framebuffer && framebuffer->HasSRGBAttachments();
     state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
   }
   return valid;
 }
 
 bool GLES2DecoderImpl::CheckBoundReadFramebufferValid(
-    const char* func_name, GLenum gl_error) {
+    const char* func_name, GLenum gl_error, bool may_need_workaround) {
+  if (may_need_workaround &&
+      workarounds().read_draw_buffers_missing_image &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return false;
+    }
+  }
   GLenum target = features().chromium_framebuffer_multisample ?
       GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   bool valid = CheckFramebufferValid(
       framebuffer, target, gl_error, func_name);
   return valid;
 }
 
 bool GLES2DecoderImpl::CheckBoundFramebufferValid(const char* func_name) {
   GLenum target = features().chromium_framebuffer_multisample ?
@@ skipping 1848 matching lines @@
     case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
     case GL_IMPLEMENTATION_COLOR_READ_TYPE:
       // They are not supported on Desktop GL until 4.1, but could be exposed
       // through GL_OES_read_format extension. However, a conflicting extension
       // GL_ARB_ES2_compatibility specifies an error case when requested on
       // integer/floating point buffers.
       // To simpify the handling, we just query and check for GL errors. If an
       // GL error occur, we fall back to our internal implementation.
       *num_written = 1;
       if (!CheckBoundReadFramebufferValid("glGetIntegerv",
-                                          GL_INVALID_OPERATION)) {
+                                          GL_INVALID_OPERATION,
+                                          false)) {
         if (params) {
           *params = 0;
         }
         return true;
       }
       if (params) {
         ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::GetHelper",
                                            GetErrorState());
         glGetIntegerv(pname, params);
         bool is_valid = glGetError() == GL_NO_ERROR;
@@ skipping 1025 matching lines @@
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glDeleteProgram", "unknown program");
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::DoClear(GLbitfield mask) {
   const char* func_name = "glClear";
   DCHECK(!ShouldDeferDraws());
-  if (CheckBoundDrawFramebufferValid(func_name)) {
+  if ((mask & GL_COLOR_BUFFER_BIT) != 0 &&

[Zhenyao Mo, 2016/11/16 03:27:27]

This is wrong.  See below.

+      workarounds().read_draw_buffers_missing_image &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true)) {
+      if ((mask & GL_DEPTH_BUFFER_BIT) == 0 &&
+          (mask & GL_STENCIL_BUFFER_BIT) == 0) {
+        return error::kNoError;
+      } else {
+        mask &= ~GL_COLOR_BUFFER_BIT;
+      }
+    }
+  }
+  if (CheckBoundDrawFramebufferValid(func_name, false)) {
     ApplyDirtyState();
     if (workarounds().gl_clear_broken) {
       if (!BoundFramebufferHasDepthAttachment())
         mask &= ~GL_DEPTH_BUFFER_BIT;
       if (!BoundFramebufferHasStencilAttachment())
         mask &= ~GL_STENCIL_BUFFER_BIT;
       ClearFramebufferForWorkaround(mask);
       return error::kNoError;
     }
     if (mask & GL_COLOR_BUFFER_BIT) {
       Framebuffer* framebuffer =
           framebuffer_state_.bound_draw_framebuffer.get();
       if (framebuffer && framebuffer->ContainsActiveIntegerAttachments()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
             "can't be called on integer buffers");
         return error::kNoError;
       }
     }
     glClear(mask);
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoClearBufferiv(GLenum buffer,
                                        GLint drawbuffer,
                                        const volatile GLint* value) {
+  if (workarounds().read_draw_buffers_missing_image &&
+      buffer == GL_COLOR &&
+      framebuffer_state_.clear_state_dirty) {
+    if (SpecifiedDrawBufferHasNoImage(drawbuffer))

[Zhenyao Mo, 2016/11/16 03:27:28]

This is very wrong.  It's not just the image that you try to clear that's
missing will cause CheckFramebufferStatus to return wrong value, it's any not
NONE draw buffer with missing image will trigger this problem.

+      return;
+  }
   const char* func_name = "glClearBufferiv";
-  if (!CheckBoundDrawFramebufferValid(func_name))
+  if (!CheckBoundDrawFramebufferValid(func_name, false))
     return;
   ApplyDirtyState();
 
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
@@ skipping 13 matching lines @@
       return;
     }
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
   glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(value));
 }
 
 void GLES2DecoderImpl::DoClearBufferuiv(GLenum buffer,
                                         GLint drawbuffer,
                                         const volatile GLuint* value) {
+  if (workarounds().read_draw_buffers_missing_image &&
+      buffer == GL_COLOR &&
+      framebuffer_state_.clear_state_dirty) {
+    if (SpecifiedDrawBufferHasNoImage(drawbuffer))
+      return;
+  }
   const char* func_name = "glClearBufferuiv";
-  if (!CheckBoundDrawFramebufferValid(func_name))
+  if (!CheckBoundDrawFramebufferValid(func_name, false))
     return;
   ApplyDirtyState();
 
   if (drawbuffer < 0 ||
       drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
     return;
   }
   GLenum internal_format =
       GetBoundColorDrawBufferInternalFormat(drawbuffer);
   if (!GLES2Util::IsUnsignedIntegerFormat(internal_format)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "can only be called on unsigned integer buffers");
     return;
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
   glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(value));
 }
 
 void GLES2DecoderImpl::DoClearBufferfv(GLenum buffer,
                                        GLint drawbuffer,
                                        const volatile GLfloat* value) {
+  if (workarounds().read_draw_buffers_missing_image &&
+      buffer == GL_COLOR &&
+      framebuffer_state_.clear_state_dirty) {
+    if (SpecifiedDrawBufferHasNoImage(drawbuffer))
+      return;
+  }
   const char* func_name = "glClearBufferfv";
-  if (!CheckBoundDrawFramebufferValid(func_name))
+  if (!CheckBoundDrawFramebufferValid(func_name, false))
     return;
   ApplyDirtyState();
 
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
@@ skipping 13 matching lines @@
       return;
     }
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
   glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(value));
 }
 
 void GLES2DecoderImpl::DoClearBufferfi(
     GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
   const char* func_name = "glClearBufferfi";
-  if (!CheckBoundDrawFramebufferValid(func_name))
+  if (!CheckBoundDrawFramebufferValid(func_name, false))
     return;
   ApplyDirtyState();
 
   if (drawbuffer != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, func_name, "invalid drawBuffer");
     return;
   }
   if (!BoundFramebufferHasDepthAttachment() &&
       !BoundFramebufferHasStencilAttachment()) {
@@ skipping 177 matching lines @@
       state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
       state_.color_clear_alpha);
   glClearStencil(state_.stencil_clear);
   glClearDepth(state_.depth_clear);
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
                                   state_.enable_flags.scissor_test);
   glScissor(state_.scissor_x, state_.scissor_y, state_.scissor_width,
             state_.scissor_height);
 }
 
+bool GLES2DecoderImpl::SpecifiedDrawBufferHasNoImage(GLint ii) {

[Zhenyao Mo, 2016/11/16 03:27:27]

No need for this function.

+  if (ii < 0 || ii >= static_cast<GLint>(group_->max_draw_buffers()))
+    return false;
+  const Framebuffer* framebuffer =
+      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  if (!framebuffer)
+    return false;
+  GLenum attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + ii);
+  if (!(framebuffer->GetAttachment(attachment)) &&
+      framebuffer->ColorBuffersHaveImage()) {
+    return true;
+  }
+  return false;
+}
+
+bool GLES2DecoderImpl::AdjustColorBufferAttachmentsIfNecessary(
+    bool read, bool draw) {
+  DCHECK(workarounds().read_draw_buffers_missing_image &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty);
+  if (read) {
+    const Framebuffer* framebuffer =
+        GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+    if (framebuffer &&
+        framebuffer->ReadBufferHasNoImage() &&
+        framebuffer->ColorBuffersHaveImage()) {
+      glReadBuffer(GL_NONE);
+      return false;
+    }
+  } else {
+    GLsizei num = 0;
+    GLsizei total = group_->max_draw_buffers();
+    GLenum safe_bufs[16];
+    for (int i = 0; i < 16; ++i)
+      safe_bufs[i] = GL_NONE;
+    const Framebuffer* framebuffer =
+        GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+    if (framebuffer &&
+        framebuffer->DrawBuffersHaveMissingImage(&num, safe_bufs) &&
+        framebuffer->ColorBuffersHaveImage()) {
+      glDrawBuffersARB(total, safe_bufs);
+      if (num == 0) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
   GLenum completeness = framebuffer->IsPossiblyComplete(feature_info_.get());
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     return completeness;
   }
+
+  bool has_image = true;
+  if (workarounds().read_draw_buffers_missing_image &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (target == GL_READ_FRAMEBUFFER) {
+      has_image = AdjustColorBufferAttachmentsIfNecessary(true, false);
+    } else {
+      has_image = AdjustColorBufferAttachmentsIfNecessary(false, true);
+    }
+    if (!has_image) {
+      return GL_FRAMEBUFFER_COMPLETE;
+    }
+  }
+
   return framebuffer->GetStatus(texture_manager(), target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   DoFramebufferTexture2DCommon(
     "glFramebufferTexture2D", target, attachment,
     textarget, client_texture_id, level, 0);
 }
@@ skipping 270 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::DoBlitFramebufferCHROMIUM(
     GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
     GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
     GLbitfield mask, GLenum filter) {
   const char* func_name = "glBlitFramebufferCHROMIUM";
   DCHECK(!ShouldDeferReads() && !ShouldDeferDraws());
 
+  if (workarounds().read_draw_buffers_missing_image &&
+      (mask & GL_COLOR_BUFFER_BIT) != 0 &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true)) {
+      return;
+    }
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return;
+    }
+  }
   if (!CheckBoundFramebufferValid(func_name)) {
     return;
   }
 
   if (GetBoundFramebufferSamples(GL_DRAW_FRAMEBUFFER) > 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                        "destination framebuffer is multisampled");
     return;
   }
 
@@ skipping 1954 matching lines @@
     return error::kNoError;
   }
   if (count < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (primcount < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
-  if (!CheckBoundDrawFramebufferValid(function_name)) {
+  if (!CheckBoundDrawFramebufferValid(function_name, true)) {
     return error::kNoError;
   }
   // We have to check this here because the prototype for glDrawArrays
   // is GLint not GLsizei.
   if (first < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "first < 0");
     return error::kNoError;
   }
 
   if (feature_info_->IsWebGL2OrES3Context()) {
@@ skipping 143 matching lines @@
   if (primcount < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
   Buffer* element_array_buffer = buffer_manager()->RequestBufferAccess(
       &state_, GL_ELEMENT_ARRAY_BUFFER, function_name);
   if (!element_array_buffer) {
     return error::kNoError;
   }
 
-  if (!CheckBoundDrawFramebufferValid(function_name)) {
+  if (!CheckBoundDrawFramebufferValid(function_name, true)) {
     return error::kNoError;
   }
 
   if (state_.bound_transform_feedback.get() &&
       state_.bound_transform_feedback->active() &&
       !state_.bound_transform_feedback->paused()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
         "transformfeedback is active and not paused");
     return error::kNoError;
   }
@@ skipping 1204 matching lines @@
 
   if (!validators_->read_pixel_format.IsValid(format)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, format, "format");
     return error::kNoError;
   }
   if (!validators_->read_pixel_type.IsValid(type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, type, "type");
     return error::kNoError;
   }
 
-  if (!CheckBoundReadFramebufferValid(
-          func_name, GL_INVALID_FRAMEBUFFER_OPERATION)) {
+  if (!CheckBoundReadFramebufferValid(func_name,
+                                      GL_INVALID_FRAMEBUFFER_OPERATION,
+                                      true)) {
     return error::kNoError;
   }
   GLenum src_internal_format = GetBoundReadFramebufferInternalFormat();
   if (src_internal_format == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "no valid color image");
     return error::kNoError;
   }
   std::vector<GLenum> accepted_formats;
   std::vector<GLenum> accepted_types;
   switch (src_internal_format) {
@@ skipping 2612 matching lines @@
     return;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, func_name, "dimensions out of range");
     return;
   }
 
   if (!CheckBoundReadFramebufferValid(func_name,
-                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
+                                      GL_INVALID_FRAMEBUFFER_OPERATION,
+                                      true)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
   GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
   }
 
@@ skipping 226 matching lines @@
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(target, level, &type, &internal_format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
   if (!CheckBoundReadFramebufferValid(func_name,
-                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
+                                      GL_INVALID_FRAMEBUFFER_OPERATION,
+                                      true)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
   GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
   }
 
@@ skipping 95 matching lines @@
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(target, level, &type, &internal_format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, zoffset, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
   if (!CheckBoundReadFramebufferValid(func_name,
-                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
+                                      GL_INVALID_FRAMEBUFFER_OPERATION,
+                                      true)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
   GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
   }
 
@@ skipping 3990 matching lines @@
   GLuint mask = 0;
   if (!v.GetFillModeAndMask(c, &fill_mode, &mask))
     return v.error();
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     // "If /path/ does not name an existing path object, the command does
     // nothing (and no error is generated)."
     // This holds for other rendering functions, too.
     return error::kNoError;
   }
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilFillPathNV(service_id, fill_mode, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilStrokePathCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilStrokePathCHROMIUM";
   const volatile gles2::cmds::StencilStrokePathCHROMIUM& c =
       *static_cast<const volatile gles2::cmds::StencilStrokePathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     return error::kNoError;
   }
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilStrokePathNV(service_id, reference, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverFillPathCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   static const char kFunctionName[] = "glCoverFillPathCHROMIUM";
   const volatile gles2::cmds::CoverFillPathCHROMIUM& c =
       *static_cast<const volatile gles2::cmds::CoverFillPathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glCoverFillPathNV(service_id, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverStrokePathCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   static const char kFunctionName[] = "glCoverStrokePathCHROMIUM";
   const volatile gles2::cmds::CoverStrokePathCHROMIUM& c =
       *static_cast<const volatile gles2::cmds::CoverStrokePathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glCoverStrokePathNV(service_id, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilThenCoverFillPathCHROMIUM";
   const volatile gles2::cmds::StencilThenCoverFillPathCHROMIUM& c =
       *static_cast<
           const volatile gles2::cmds::StencilThenCoverFillPathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetFillModeAndMask(c, &fill_mode, &mask) ||
       !v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilThenCoverFillPathNV(service_id, fill_mode, mask, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverStrokePathCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilThenCoverStrokePathCHROMIUM";
   const volatile gles2::cmds::StencilThenCoverStrokePathCHROMIUM& c =
       *static_cast<
           const volatile gles2::cmds::StencilThenCoverStrokePathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilThenCoverStrokePathNV(service_id, reference, mask, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFillPathInstancedCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilFillPathInstancedCHROMIUM";
@@ skipping 19 matching lines @@
     return error::kNoError;
 
   std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                fill_mode, mask, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilStrokePathInstancedCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
   std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                  reference, mask, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverFillPathInstancedCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 18 matching lines @@
     return error::kNoError;
 
   std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                              cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverStrokePathInstancedCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 19 matching lines @@
     return error::kNoError;
 
   std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glCoverStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathInstancedCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
@@ skipping 22 matching lines @@
     return error::kNoError;
 
   std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilThenCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(),
                                         0, fill_mode, mask, cover_mode,
                                         transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderImpl::HandleStencilThenCoverStrokePathInstancedCHROMIUM(
@@ skipping 23 matching lines @@
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
 
-  if (!CheckBoundDrawFramebufferValid(kFunctionName))
+  if (!CheckBoundDrawFramebufferValid(kFunctionName, false))
     return error::kNoError;
   ApplyDirtyState();
   glStencilThenCoverStrokePathInstancedNV(
       num_paths, GL_UNSIGNED_INT, paths.get(), 0, reference, mask, cover_mode,
       transform_type, transforms);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBindFragmentInputLocationCHROMIUM(
     GLuint program_id,
@@ skipping 261 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