[WIP] Remove unnecessary clear_state_dirty

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 4031 matching lines @@
     if (framebuffer && !framebuffer->IsDeleted()) {
       if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
         GLenum target = GetDrawFramebufferTarget();
 
         // Unbind attachments on FBO before deletion.
         if (workarounds().unbind_attachments_on_bound_render_fbo_delete)
           framebuffer->DoUnbindGLAttachmentsForWorkaround(target);
 
         glBindFramebufferEXT(target, GetBackbufferServiceId());
         framebuffer_state_.bound_draw_framebuffer = NULL;
-        framebuffer_state_.clear_state_dirty = true;
+        // framebuffer_state_.clear_state_dirty = true;
       }
       if (framebuffer == framebuffer_state_.bound_read_framebuffer.get()) {
         framebuffer_state_.bound_read_framebuffer = NULL;
         GLenum target = GetReadFramebufferTarget();
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
       OnFboChanged();
       RemoveFramebuffer(client_id);
     }
   }
@@ skipping 20 matching lines @@
         if (framebuffer_state_.bound_draw_framebuffer.get()) {
           framebuffer_state_.bound_draw_framebuffer
               ->UnbindRenderbuffer(GL_DRAW_FRAMEBUFFER_EXT, renderbuffer);
         }
       } else {
         if (framebuffer_state_.bound_draw_framebuffer.get()) {
           framebuffer_state_.bound_draw_framebuffer
               ->UnbindRenderbuffer(GL_FRAMEBUFFER, renderbuffer);
         }
       }
-      framebuffer_state_.clear_state_dirty = true;
+      // framebuffer_state_.clear_state_dirty = true;
       RemoveRenderbuffer(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(GLsizei n,
                                             const volatile GLuint* client_ids) {
   bool supports_separate_framebuffer_binds = SupportsSeparateFramebufferBinds();
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     TextureRef* texture_ref = GetTexture(client_id);
     if (texture_ref) {
       Texture* texture = texture_ref->texture();
       if (texture->IsAttachedToFramebuffer()) {
-        framebuffer_state_.clear_state_dirty = true;
+      //  framebuffer_state_.clear_state_dirty = true;
       }
       // Unbind texture_ref from texture_ref units.
       state_.UnbindTexture(texture_ref);
 
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
         if (framebuffer_state_.bound_read_framebuffer.get()) {
           framebuffer_state_.bound_read_framebuffer
               ->UnbindTexture(GL_READ_FRAMEBUFFER_EXT, texture_ref);
         }
@@ skipping 112 matching lines @@
   GLuint framebuffer_id = framebuffer ? framebuffer->service_id() : 0;
 
   if (framebuffer_id == 0) {
     framebuffer_id = back_buffer_service_id;
   }
 
   glBindFramebufferEXT(target, framebuffer_id);
 }
 
 void GLES2DecoderImpl::RestoreCurrentFramebufferBindings() {
-  framebuffer_state_.clear_state_dirty = true;
+  // framebuffer_state_.clear_state_dirty = true;
 
   if (!SupportsSeparateFramebufferBinds()) {
     RebindCurrentFramebuffer(
         GL_FRAMEBUFFER,
         framebuffer_state_.bound_draw_framebuffer.get(),
         GetBackbufferServiceId());
   } else {
     RebindCurrentFramebuffer(
         GL_READ_FRAMEBUFFER_EXT,
         framebuffer_state_.bound_read_framebuffer.get(),
@@ skipping 1229 matching lines @@
   if (framebuffer) {
     return framebuffer->HasStencilAttachment();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_stencil_format_ != 0 ||
            offscreen_target_depth_format_ == GL_DEPTH24_STENCIL8;
   }
   return back_buffer_has_stencil_;
 }
 
-void GLES2DecoderImpl::ApplyDirtyState() {
+/* void GLES2DecoderImpl::ApplyDirtyState() {
   if (framebuffer_state_.clear_state_dirty) {
+    // print("**** enter ApplyDirtyState ****\n");
     bool allows_alpha_change = BoundFramebufferAllowsChangesToAlphaChannel();
     state_.SetDeviceColorMask(state_.color_mask_red, state_.color_mask_green,
                               state_.color_mask_blue,
                               state_.color_mask_alpha && allows_alpha_change);
 
     bool have_depth = BoundFramebufferHasDepthAttachment();
     state_.SetDeviceDepthMask(state_.depth_mask && have_depth);
 
     bool have_stencil = BoundFramebufferHasStencilAttachment();
     state_.SetDeviceStencilMaskSeparate(
         GL_FRONT, have_stencil ? state_.stencil_front_writemask : 0);
     state_.SetDeviceStencilMaskSeparate(
         GL_BACK, have_stencil ? state_.stencil_back_writemask : 0);
 
     state_.SetDeviceCapabilityState(
         GL_DEPTH_TEST, state_.enable_flags.depth_test && have_depth);
     state_.SetDeviceCapabilityState(
         GL_STENCIL_TEST, state_.enable_flags.stencil_test && have_stencil);
     framebuffer_state_.clear_state_dirty = false;
   }
 }
+*/
+void GLES2DecoderImpl::ApplyDirtyState() {
+  if (framebuffer_state_.clear_state_dirty) {
+    // print("**** enter ApplyDirtyState ****\n");
+    // bool allows_alpha_change = BoundFramebufferAllowsChangesToAlphaChannel();
+    state_.SetDeviceColorMask(state_.color_mask_red, state_.color_mask_green,
+                              state_.color_mask_blue,
+                              // state_.color_mask_alpha && allows_alpha_change);
+                              state_.color_mask_alpha);
+
+    // bool have_depth = BoundFramebufferHasDepthAttachment();
+    // state_.SetDeviceDepthMask(state_.depth_mask && have_depth);
+    state_.SetDeviceDepthMask(state_.depth_mask);
+
+    // bool have_stencil = BoundFramebufferHasStencilAttachment();
+    state_.SetDeviceStencilMaskSeparate(
+        // GL_FRONT, have_stencil ? state_.stencil_front_writemask : 0);
+        GL_FRONT, state_.stencil_front_writemask);
+    state_.SetDeviceStencilMaskSeparate(
+        // GL_BACK, have_stencil ? state_.stencil_back_writemask : 0);
+        GL_BACK, state_.stencil_back_writemask);
+
+    state_.SetDeviceCapabilityState(
+        // GL_DEPTH_TEST, state_.enable_flags.depth_test && have_depth);
+        GL_DEPTH_TEST, state_.enable_flags.depth_test);
+    state_.SetDeviceCapabilityState(
+        // GL_STENCIL_TEST, state_.enable_flags.stencil_test && have_stencil);
+        GL_STENCIL_TEST, state_.enable_flags.stencil_test);
+    framebuffer_state_.clear_state_dirty = false;
+  }
+}
 
 GLuint GLES2DecoderImpl::GetBackbufferServiceId() const {
   return (offscreen_target_frame_buffer_.get())
              ? offscreen_target_frame_buffer_->id()
              : (surface_.get() ? surface_->GetBackingFramebufferObject() : 0);
 }
 
 void GLES2DecoderImpl::RestoreState(const ContextState* prev_state) {
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::RestoreState",
                "context", logger_.GetLogPrefix());
@@ skipping 122 matching lines @@
 
   if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
     framebuffer_state_.bound_draw_framebuffer = framebuffer;
   }
 
   // vmiura: This looks like dup code
   if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
     framebuffer_state_.bound_read_framebuffer = framebuffer;
   }
 
-  framebuffer_state_.clear_state_dirty = true;
+  // framebuffer_state_.clear_state_dirty = true;
 
   // If we are rendering to the backbuffer get the FBO id for any simulated
   // backbuffer.
   if (framebuffer == NULL) {
     service_id = GetBackbufferServiceId();
   }
 
   glBindFramebufferEXT(target, service_id);
   OnFboChanged();
 }
@@ skipping 1772 matching lines @@
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferRenderbuffer");
   for (GLenum attachment_point : attachments) {
     glFramebufferRenderbufferEXT(
         target, attachment_point, renderbuffertarget, service_id);
     GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferRenderbuffer");
     if (error == GL_NO_ERROR) {
       framebuffer->AttachRenderbuffer(attachment_point, renderbuffer);
     }
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-    framebuffer_state_.clear_state_dirty = true;
+    // framebuffer_state_.clear_state_dirty = true;
   }
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
     if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX &&
         feature_info_->feature_flags().emulate_primitive_restart_fixed_index) {
       // Enable and Disable PRIMITIVE_RESTART only before and after
       // DrawElements* for old desktop GL.
@@ skipping 233 matching lines @@
             target, attachments[ii], textarget, service_id, level, samples);
       }
     }
     GLenum error = LOCAL_PEEK_GL_ERROR(name);
     if (error == GL_NO_ERROR) {
       framebuffer->AttachTexture(attachments[ii], texture_ref, textarget, level,
                                  samples);
     }
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-    framebuffer_state_.clear_state_dirty = true;
+    // framebuffer_state_.clear_state_dirty = true;
   }
 
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoFramebufferTextureLayer(
     GLenum target, GLenum attachment, GLuint client_texture_id,
     GLint level, GLint layer) {
   const char* function_name = "glFramebufferTextureLayer";
 
@@ skipping 36 matching lines @@
   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;
+    // framebuffer_state_.clear_state_dirty = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target,
     GLenum attachment,
     GLenum pname,
     GLint* params,
     GLsizei params_size) {
   const char kFunctionName[] = "glGetFramebufferAttachmentParameteriv";
@@ skipping 1815 matching lines @@
           continue;
         }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::ClearUnclearedTextures() {
+  // print("**** enter ClearUnclearedTextures ****\n");
   // Only check if there are some uncleared textures.
   if (!texture_manager()->HaveUnsafeTextures()) {
     return true;
   }
 
   // 1: Check all textures we are about to render with.
   if (state_.current_program.get()) {
     const Program::SamplerIndices& sampler_indices =
         state_.current_program->sampler_indices();
     for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
       const Program::UniformInfo* uniform_info =
           state_.current_program->GetUniformInfo(sampler_indices[ii]);
       DCHECK(uniform_info);
       for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
         GLuint texture_unit_index = uniform_info->texture_units[jj];
         if (texture_unit_index < state_.texture_units.size()) {
           TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
           TextureRef* texture_ref =
               texture_unit.GetInfoForSamplerType(uniform_info->type).get();
           if (texture_ref && !texture_ref->texture()->SafeToRenderFrom()) {
             if (!texture_manager()->ClearRenderableLevels(this, texture_ref)) {
               return false;
             }
           }
         }
       }
     }
   }
+  // RestoreClearState();
   return true;
 }
 
 bool GLES2DecoderImpl::IsDrawValid(
     const char* function_name, GLuint max_vertex_accessed, bool instanced,
     GLsizei primcount) {
   DCHECK(instanced || primcount == 1);
 
   // NOTE: We specifically do not check current_program->IsValid() because
   // it could never be invalid since glUseProgram would have failed. While
@@ skipping 518 matching lines @@
     bool simulated_attrib_0 = false;
     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();
+      // print("#### may enter ApplyDirtyState ****\n");
       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);
       }
       if (!ValidateAndAdjustDrawBuffers(function_name)) {
         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);
       }
+      // RestoreClearState();
       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);
       }
@@ skipping 3273 matching lines @@
                                      internal_format, image_size, data)) {
     return error::kNoError;
   }
 
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    // framebuffer_state_.clear_state_dirty = true;
   }
 
   std::unique_ptr<int8_t[]> zero;
   if (!state_.bound_pixel_unpack_buffer && !data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(func_name);
   const CompressedFormatInfo* format_info =
@@ skipping 586 matching lines @@
         GL_INVALID_OPERATION,
         func_name, "source and destination textures are the same");
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(func_name);
   ScopedResolvedFramebufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFramebufferSize();
 
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    // framebuffer_state_.clear_state_dirty = true;
   }
 
   bool requires_luma_blit =
       CopyTexImageResourceManager::CopyTexImageRequiresBlit(feature_info_.get(),
                                                             format);
   if (requires_luma_blit &&
       !InitializeCopyTexImageBlitter(func_name)) {
     return;
   }
 
@@ skipping 2811 matching lines @@
   }
   TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "unknown texture for target");
     return;
   }
   Texture* texture = texture_ref->texture();
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    // framebuffer_state_.clear_state_dirty = true;
   }
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "texture is immutable");
     return;
   }
 
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
@@ skipping 2194 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