[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);
   // 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);
   // 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(
+    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 &&
+      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))
+      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) {
+  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 2604 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 3992 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