Split DEPTH_STENCIL into DEPTH and STENCIL in command buffer

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 6953 matching lines @@
     return;
   }
   MarkDrawBufferAsCleared(GL_DEPTH, drawbuffer);
   MarkDrawBufferAsCleared(GL_STENCIL, drawbuffer);
   glClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
     GLuint client_renderbuffer_id) {
+  const char* func_name = "glFramebufferRenderbuffer";
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glFramebufferRenderbuffer", "no framebuffer bound");
+        GL_INVALID_OPERATION, func_name, "no framebuffer bound");
     return;
   }
   GLuint service_id = 0;
   Renderbuffer* renderbuffer = NULL;
   if (client_renderbuffer_id) {
     renderbuffer = GetRenderbuffer(client_renderbuffer_id);
     if (!renderbuffer) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
-          "glFramebufferRenderbuffer", "unknown renderbuffer");
+          func_name, "unknown renderbuffer");
       return;
     }
     service_id = renderbuffer->service_id();
   }
-  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferRenderbuffer");
+  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(func_name);
   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
     glFramebufferRenderbufferEXT(
         target, GL_DEPTH_ATTACHMENT, renderbuffertarget, service_id);
     glFramebufferRenderbufferEXT(
         target, GL_STENCIL_ATTACHMENT, renderbuffertarget, service_id);
   } else {
     glFramebufferRenderbufferEXT(
         target, attachment, renderbuffertarget, service_id);
   }
-  GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferRenderbuffer");
+  GLenum error = LOCAL_PEEK_GL_ERROR(func_name);
   if (error == GL_NO_ERROR) {
-    framebuffer->AttachRenderbuffer(attachment, renderbuffer);
+    if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      framebuffer->AttachRenderbuffer(GL_DEPTH_ATTACHMENT, renderbuffer);
+      framebuffer->AttachRenderbuffer(GL_STENCIL_ATTACHMENT, renderbuffer);
+    } else {
+      framebuffer->AttachRenderbuffer(attachment, renderbuffer);
+    }
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
     if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX &&
@@ skipping 67 matching lines @@
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     clear_bits |= GL_COLOR_BUFFER_BIT;
 
     if (SupportsDrawBuffers()) {
       reset_draw_buffers =
           framebuffer->PrepareDrawBuffersForClearingUninitializedAttachments();
     }
   }
 
-  if (framebuffer->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT) ||
-      framebuffer->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
+  if (framebuffer->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT)) {
     glClearStencil(0);
     state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
     state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
     clear_bits |= GL_STENCIL_BUFFER_BIT;
   }
 
-  if (framebuffer->HasUnclearedAttachment(GL_DEPTH_ATTACHMENT) ||
-      framebuffer->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
+  if (framebuffer->HasUnclearedAttachment(GL_DEPTH_ATTACHMENT)) {
     glClearDepth(1.0f);
     state_.SetDeviceDepthMask(GL_TRUE);
     clear_bits |= GL_DEPTH_BUFFER_BIT;
   }
 
   if (clear_bits) {
     if (!cleared_int_renderbuffers &&
         target == GL_READ_FRAMEBUFFER && draw_framebuffer != framebuffer) {
       // TODO(zmo): There is no guarantee that an FBO that is complete on the
       // READ attachment will be complete as a DRAW attachment.
@@ skipping 124 matching lines @@
         glFramebufferTexture2DMultisampleIMG(
             target, attachments[ii], textarget, service_id, level, samples);
       } else {
         glFramebufferTexture2DMultisampleEXT(
             target, attachments[ii], textarget, service_id, level, samples);
       }
     }
   }
   GLenum error = LOCAL_PEEK_GL_ERROR(name);
   if (error == GL_NO_ERROR) {
-    framebuffer->AttachTexture(attachment, texture_ref, textarget, level,
-         samples);
+    if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      framebuffer->AttachTexture(
+          GL_DEPTH_ATTACHMENT, texture_ref, textarget, level, samples);
+      framebuffer->AttachTexture(
+          GL_STENCIL_ATTACHMENT, texture_ref, textarget, level, samples);
+    } else {
+      framebuffer->AttachTexture(
+          attachment, texture_ref, textarget, level, samples);
+    }
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoFramebufferTextureLayer(
     GLenum target, GLenum attachment, GLuint client_texture_id,
@@ skipping 28 matching lines @@
             "texture is neither TEXTURE_3D nor TEXTURE_2D_ARRAY");
         return;
     }
     if (!texture_manager()->ValidForTarget(texture_target, level,
                                            0, 0, layer)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, function_name, "invalid level or layer");
       return;
     }
   }
-  glFramebufferTextureLayer(target, attachment, service_id, level, layer);
-  framebuffer->AttachTextureLayer(
-      attachment, texture_ref, texture_target, level, layer);
+  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name);
+  if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+    glFramebufferTextureLayer(
+        target, GL_DEPTH_ATTACHMENT, service_id, level, layer);
+    glFramebufferTextureLayer(
+        target, GL_STENCIL_ATTACHMENT, service_id, level, layer);
+  } else {
+    glFramebufferTextureLayer(target, attachment, service_id, level, layer);
+  }
+  GLenum error = LOCAL_PEEK_GL_ERROR(function_name);
+  if (error == GL_NO_ERROR) {
+    if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      framebuffer->AttachTextureLayer(
+          GL_DEPTH_ATTACHMENT, texture_ref, texture_target, level, layer);
+      framebuffer->AttachTextureLayer(
+          GL_STENCIL_ATTACHMENT, texture_ref, texture_target, level, layer);
+    } else {
+      framebuffer->AttachTextureLayer(
+          attachment, texture_ref, texture_target, level, layer);
+    }
+  }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   const char kFunctionName[] = "glGetFramebufferAttachmentParameteriv";
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
@@ skipping 10145 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