Enforce RGB even on buggy drivers.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 108 matching lines @@
 };
 
 static bool IsAngle() {
 #if defined(OS_WIN)
   return gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
 #else
   return false;
 #endif
 }
 
-void WrappedTexImage2D(
+static void WrappedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
     const void* pixels) {
   GLenum gl_internal_format = internal_format;
@@ skipping 588 matching lines @@
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
   virtual void SetLatchCallback(const base::Callback<void(bool)>& callback);;
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id);
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
   void RestoreCurrentRenderbufferBindings();
   void RestoreCurrentTexture2DBindings();
 
+  // Sets DEPTH_TEST, STENCIL_TEST and color mask for the current framebuffer.
+  void ApplyDirtyState();
+
+  // These check the state of the currently bound framebuffer or the
+  // backbuffer if no framebuffer is bound.
+  bool BoundFramebufferHasColorAttachmentWithAlpha();
+  bool BoundFramebufferHasDepthAttachment();
+  bool BoundFramebufferHasStencilAttachment();
+
  private:
   friend class ScopedGLErrorSuppressor;
   friend class ScopedResolvedFrameBufferBinder;
   friend class RenderBuffer;
   friend class FrameBuffer;
 
   // State associated with each texture unit.
   struct TextureUnit {
     TextureUnit() : bind_target(GL_TEXTURE_2D) { }
 
@@ skipping 69 matching lines @@
     texture_manager()->RemoveTextureInfo(feature_info_, client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
   gfx::Size GetBoundReadFrameBufferSize();
 
   // Get the format of the currently bound frame buffer (either FBO or regular
   // back buffer)
   GLenum GetBoundReadFrameBufferInternalFormat();
+  GLenum GetBoundDrawFrameBufferInternalFormat();
 
   // Wrapper for CompressedTexImage2D commands.
   error::Error DoCompressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLsizei image_size,
@@ skipping 415 matching lines @@
   void DoVertexAttrib2fv(GLuint index, const GLfloat *v);
   void DoVertexAttrib3fv(GLuint index, const GLfloat *v);
   void DoVertexAttrib4fv(GLuint index, const GLfloat *v);
 
   // Wrapper for glUseProgram
   void DoUseProgram(GLuint program);
 
   // Wrapper for glValidateProgram.
   void DoValidateProgram(GLuint program_client_id);
 
-  void DoCopyTextureToParentTextureCHROMIUM(GLuint client_texture_id,
-                                    GLuint parent_client_texture_id);
+  void DoCopyTextureToParentTextureCHROMIUM(
+      GLuint client_texture_id, GLuint parent_client_texture_id);
 
   void DoResizeCHROMIUM(GLuint width, GLuint height);
 
   void DoSetSurfaceCHROMIUM(GLint surface_id);
 
   // Gets the number of values that will be returned by glGetXXX. Returns
   // false if pname is unknown.
   bool GetNumValuesReturnedForGLGet(GLenum pname, GLsizei* num_values);
 
   // Gets the GLError through our wrapper.
@@ skipping 181 matching lines @@
   GLboolean mask_red_;
   GLboolean mask_green_;
   GLboolean mask_blue_;
   GLboolean mask_alpha_;
   GLint clear_stencil_;
   GLuint mask_stencil_front_;
   GLuint mask_stencil_back_;
   GLclampf clear_depth_;
   GLboolean mask_depth_;
   bool enable_scissor_test_;
+  bool state_dirty_;
 
   // The program in use by glUseProgram
   ProgramManager::ProgramInfo::Ref current_program_;
 
   // The currently bound framebuffers
   FramebufferManager::FramebufferInfo::Ref bound_read_framebuffer_;
   FramebufferManager::FramebufferInfo::Ref bound_draw_framebuffer_;
 
   // The currently bound renderbuffer
   RenderbufferManager::RenderbufferInfo::Ref bound_renderbuffer_;
@@ skipping 19 matching lines @@
   scoped_ptr<FrameBuffer> offscreen_saved_frame_buffer_;
   scoped_ptr<Texture> offscreen_saved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<Callback1<gfx::Size>::Type> resize_callback_;
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
   base::Callback<void(bool)> latch_callback_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
+  bool back_buffer_has_depth_;
+  bool back_buffer_has_stencil_;
 
   bool teximage2d_faster_than_texsubimage2d_;
   bool bufferdata_faster_than_buffersubdata_;
 
   // The last error message set.
   std::string last_error_;
 
   // The current decoder error.
   error::Error current_decoder_error_;
 
@@ skipping 323 matching lines @@
       mask_red_(true),
       mask_green_(true),
       mask_blue_(true),
       mask_alpha_(true),
       clear_stencil_(0),
       mask_stencil_front_(-1),
       mask_stencil_back_(-1),
       clear_depth_(1.0f),
       mask_depth_(true),
       enable_scissor_test_(false),
+      state_dirty_(true),
       offscreen_target_color_format_(0),
       offscreen_target_depth_format_(0),
       offscreen_target_stencil_format_(0),
       offscreen_target_samples_(0),
       copy_texture_to_parent_texture_fb_(0),
       offscreen_saved_color_format_(0),
       back_buffer_color_format_(0),
+      back_buffer_has_depth_(false),
+      back_buffer_has_stencil_(false),
       teximage2d_faster_than_texsubimage2d_(true),
       bufferdata_faster_than_buffersubdata_(true),
       current_decoder_error_(error::kNoError),
       use_shader_translator_(true),
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()),
       tex_image_2d_failed_(false),
       frame_number_(0) {
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
@@ skipping 59 matching lines @@
                << "failed to initialize.";
     Destroy();
     return false;
   }
 
   CHECK_GL_ERROR();
   disallowed_extensions_ = disallowed_extensions;
 
   vertex_attrib_manager_.Initialize(group_->max_vertex_attribs());
 
-  GLint v = 0;
-  glGetIntegerv(GL_ALPHA_BITS, &v);
-  back_buffer_color_format_ = v ? GL_RGBA : GL_RGB;
-
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
 
   texture_units_.reset(
       new TextureUnit[group_->max_texture_units()]);
   for (uint32 tt = 0; tt < group_->max_texture_units(); ++tt) {
     glActiveTexture(GL_TEXTURE0 + tt);
     // Do cube map first because we want the last bind to be 2D.
     TextureManager::TextureInfo* info =
         texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
     texture_units_[tt].bound_texture_cube_map = info;
     glBindTexture(GL_TEXTURE_CUBE_MAP, info->service_id());
     info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
     texture_units_[tt].bound_texture_2d = info;
     glBindTexture(GL_TEXTURE_2D, info->service_id());
   }
   glActiveTexture(GL_TEXTURE0);
   CHECK_GL_ERROR();
 
+  ContextCreationAttribParser attrib_parser;
+  if (!attrib_parser.Parse(attribs))
+    return false;
+
+  // These are NOT if the back buffer has these proprorties. They are
+  // if we want the command buffer to enforce them regardless of what
+  // the real backbuffer is assuming the real back buffer gives us more than
+  // we ask for. In other words, if we ask for RGB and we get RGBA then we'll
+  // make it appear RGB. If on the other hand we ask for RGBA nd get RGB we
+  // can't do anything about that.
+
+  GLint v = 0;
+  glGetIntegerv(GL_ALPHA_BITS, &v);
+  // This checks if the user requested RGBA and we have RGBA then RGBA. If the
+  // user requested RGB then RGB. If the user did not specify a preference than
+  // use whatever we were given. Same for DEPTH and STENCIL.
+  back_buffer_color_format_ =
+      (attrib_parser.alpha_size_ != 0 && v > 0) ? GL_RGBA : GL_RGB;
+  glGetIntegerv(GL_DEPTH_BITS, &v);
+  back_buffer_has_depth_ = attrib_parser.depth_size_ != 0 && v > 0;
+  glGetIntegerv(GL_STENCIL_BITS, &v);
+  back_buffer_has_stencil_ = attrib_parser.stencil_size_ != 0 && v > 0;
+
   if (surface_->IsOffscreen()) {
-    ContextCreationAttribParser attrib_parser;
-    if (!attrib_parser.Parse(attribs))
-      return false;
-
     if (attrib_parser.samples_ > 0 && attrib_parser.sample_buffers_ > 0 &&
         (context_->HasExtension("GL_EXT_framebuffer_multisample") ||
          context_->HasExtension("GL_ANGLE_framebuffer_multisample"))) {
       // Per ext_framebuffer_multisample spec, need max bound on sample count.
       // max_sample_count must be initialized to a sane value.  If
       // glGetIntegerv() throws a GL error, it leaves its argument unchanged.
       GLint max_sample_count = 1;
       glGetIntegerv(GL_MAX_SAMPLES_EXT, &max_sample_count);
       offscreen_target_samples_ = std::min(attrib_parser.samples_,
                                            max_sample_count);
@@ skipping 248 matching lines @@
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     FramebufferManager::FramebufferInfo* info =
         GetFramebufferInfo(client_ids[ii]);
     if (info) {
+      if (info == bound_draw_framebuffer_) {
+        bound_draw_framebuffer_ = NULL;
+        state_dirty_ = true;
+      }
       GLuint service_id = info->service_id();
       glDeleteFramebuffersEXT(1, &service_id);
       RemoveFramebufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     RenderbufferManager::RenderbufferInfo* info =
         GetRenderbufferInfo(client_ids[ii]);
     if (info) {
+      state_dirty_ = true;
       GLuint service_id = info->service_id();
       glDeleteRenderbuffersEXT(1, &service_id);
       RemoveRenderbufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     TextureManager::TextureInfo* info = GetTextureInfo(client_ids[ii]);
     if (info) {
+      if (info->IsAttachedToFramebuffer()) {
+        state_dirty_ = true;
+      }
       GLuint service_id = info->service_id();
       glDeleteTextures(1, &service_id);
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
   return context_.get() ? context_->MakeCurrent(surface_.get()) : false;
 }
 
 void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
   glBindRenderbufferEXT(
       GL_RENDERBUFFER,
       bound_renderbuffer_ ? bound_renderbuffer_->service_id() : 0);
 }
 
 static void RebindCurrentFramebuffer(
     GLenum target,
     FramebufferManager::FramebufferInfo* info,
     FrameBuffer* offscreen_frame_buffer) {
   GLuint framebuffer_id = info ? info->service_id() : 0;
+
   if (framebuffer_id == 0 && offscreen_frame_buffer) {
     framebuffer_id = offscreen_frame_buffer->id();
   }
+
   glBindFramebufferEXT(target, framebuffer_id);
 }
 
 void GLES2DecoderImpl::RestoreCurrentFramebufferBindings() {
+  state_dirty_ = true;
+
   if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
     RebindCurrentFramebuffer(
         GL_FRAMEBUFFER,
         bound_draw_framebuffer_.get(),
         offscreen_target_frame_buffer_.get());
   } else {
     RebindCurrentFramebuffer(
         GL_READ_FRAMEBUFFER_EXT,
         bound_read_framebuffer_.get(),
         offscreen_target_frame_buffer_.get());
@@ skipping 36 matching lines @@
     return gfx::Size(0, 0);
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_size_;
   } else {
     return surface_->GetSize();
   }
 }
 
 GLenum GLES2DecoderImpl::GetBoundReadFrameBufferInternalFormat() {
   if (bound_read_framebuffer_ != 0) {
-    const FramebufferManager::FramebufferInfo::Attachment* attachment =
-        bound_read_framebuffer_->GetAttachment(GL_COLOR_ATTACHMENT0);
-    if (attachment) {
-      return attachment->internal_format();
-    }
-    return 0;
+    return bound_read_framebuffer_->GetColorAttachmentFormat();
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_color_format_;
   } else {
+    return back_buffer_color_format_;
+  }
+}
+
+GLenum GLES2DecoderImpl::GetBoundDrawFrameBufferInternalFormat() {
+  if (bound_draw_framebuffer_ != 0) {
+    return bound_draw_framebuffer_->GetColorAttachmentFormat();
+  } else if (offscreen_target_frame_buffer_.get()) {
+    return offscreen_target_color_format_;
+  } else {
     return back_buffer_color_format_;
   }
 }
 
 bool GLES2DecoderImpl::UpdateOffscreenFrameBufferSize() {
   if (offscreen_size_ == pending_offscreen_size_)
     return true;
 
   offscreen_size_ = pending_offscreen_size_;
   int w = offscreen_size_.width();
@@ skipping 68 matching lines @@
   if (offscreen_target_frame_buffer_->CheckStatus() !=
       GL_FRAMEBUFFER_COMPLETE) {
       LOG(ERROR) << "GLES2DecoderImpl::UpdateOffscreenFrameBufferSize failed "
                  << "because offscreen FBO was incomplete.";
     return false;
   }
 
   // Clear the target frame buffer.
   {
     ScopedFrameBufferBinder binder(this, offscreen_target_frame_buffer_->id());
-    glClearColor(0, 0, 0, 0);
+    glClearColor(0, 0, 0, offscreen_target_color_format_ == GL_RGB);
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glClearStencil(0);
     glStencilMaskSeparate(GL_FRONT, GL_TRUE);
     glStencilMaskSeparate(GL_BACK, GL_TRUE);
     glClearDepth(0);
     glDepthMask(GL_TRUE);
     glDisable(GL_SCISSOR_TEST);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     RestoreClearState();
   }
@@ skipping 360 matching lines @@
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_ = info;
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
   glBindBuffer(target, service_id);
 }
 
+bool GLES2DecoderImpl::BoundFramebufferHasColorAttachmentWithAlpha() {
+  return (GLES2Util::GetChannelsForFormat(
+      GetBoundDrawFrameBufferInternalFormat()) & 0x0008) != 0;
+}
+
+bool GLES2DecoderImpl::BoundFramebufferHasDepthAttachment() {
+  if (bound_draw_framebuffer_) {
+    return bound_draw_framebuffer_->HasDepthAttachment();
+  }
+  if (offscreen_target_frame_buffer_.get()) {
+    return offscreen_target_depth_format_ != 0;
+  }
+  return back_buffer_has_depth_;
+}
+
+bool GLES2DecoderImpl::BoundFramebufferHasStencilAttachment() {
+  if (bound_draw_framebuffer_) {
+    return bound_draw_framebuffer_->HasStencilAttachment();
+  }
+  if (offscreen_target_frame_buffer_.get()) {
+    return offscreen_target_stencil_format_ != 0;
+  }
+  return back_buffer_has_stencil_;
+}
+
+void GLES2DecoderImpl::ApplyDirtyState() {
+  if (state_dirty_) {
+    glColorMask(
+        mask_red_, mask_green_, mask_blue_,
+        mask_alpha_ && BoundFramebufferHasColorAttachmentWithAlpha());
+    glDepthMask(mask_depth_ && BoundFramebufferHasDepthAttachment());
+    glStencilMaskSeparate(
+       GL_FRONT,
+       BoundFramebufferHasStencilAttachment() ? mask_stencil_front_ : 0);
+    glStencilMaskSeparate(
+       GL_BACK,
+       BoundFramebufferHasStencilAttachment() ? mask_stencil_back_ : 0);
+    state_dirty_ = false;
+  }
+}
+
 void GLES2DecoderImpl::DoBindFramebuffer(GLenum target, GLuint client_id) {
   FramebufferManager::FramebufferInfo* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     info = GetFramebufferInfo(client_id);
     if (!info) {
       // It's a new id so make a framebuffer info for it.
       glGenFramebuffersEXT(1, &service_id);
       CreateFramebufferInfo(client_id, service_id);
       info = GetFramebufferInfo(client_id);
       IdAllocator* id_allocator =
           group_->GetIdAllocator(id_namespaces::kFramebuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
     info->MarkAsValid();
   } else {
     service_id = 0;
   }
 
   if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
     bound_draw_framebuffer_ = info;
   }
   if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
     bound_read_framebuffer_ = info;
   }
 
+  state_dirty_ = true;
+
   // When rendering to an offscreen frame buffer, instead of unbinding from
   // the current frame buffer, bind to the offscreen target frame buffer.
-  if (info == NULL && offscreen_target_frame_buffer_.get())
+  if (info == NULL && offscreen_target_frame_buffer_.get()) {
     service_id = offscreen_target_frame_buffer_->id();
+  }
 
   glBindFramebufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_id) {
   RenderbufferManager::RenderbufferInfo* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     info = GetRenderbufferInfo(client_id);
     if (!info) {
@@ skipping 133 matching lines @@
         *num_written = 2;
         if (params) {
           params[0] = renderbuffer_manager()->max_renderbuffer_size();
           params[1] = renderbuffer_manager()->max_renderbuffer_size();
         }
         return true;
       }
     }
   }
   switch (pname) {
+    case GL_COLOR_WRITEMASK:
+      *num_written = 4;
+      if (params) {
+        params[0] = mask_red_;
+        params[1] = mask_green_;
+        params[2] = mask_blue_;
+        params[3] = mask_alpha_;
+      }
+      return true;
+    case GL_DEPTH_WRITEMASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = mask_depth_;
+      }
+      return true;
+    case GL_STENCIL_BACK_WRITEMASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = mask_stencil_back_;
+      }
+      return true;
+    case GL_STENCIL_WRITEMASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = mask_stencil_front_;
+      }
+      return true;
+    case GL_ALPHA_BITS:
+      *num_written = 1;
+      if (params) {
+        GLint v = 0;
+        glGetIntegerv(GL_ALPHA_BITS, &v);
+        params[0] = BoundFramebufferHasColorAttachmentWithAlpha() ? v : 0;
+      }
+      return true;
+    case GL_DEPTH_BITS:
+      *num_written = 1;
+      if (params) {
+        GLint v = 0;
+        glGetIntegerv(GL_DEPTH_BITS, &v);
+        params[0] = BoundFramebufferHasDepthAttachment() ? v : 0;
+      }
+      return true;
+    case GL_STENCIL_BITS:
+      *num_written = 1;
+      if (params) {
+        GLint v = 0;
+        glGetIntegerv(GL_STENCIL_BITS, &v);
+        params[0] = BoundFramebufferHasStencilAttachment() ? v : 0;
+      }
+      return true;
     case GL_COMPRESSED_TEXTURE_FORMATS:
       *num_written = 0;
       // We don't support compressed textures.
       return true;
     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
       *num_written = 1;
       if (params) {
         *params = 0;  // We don't support compressed textures.
       }
       return true;
@@ skipping 371 matching lines @@
   }
   if (ids == NULL) {
     return error::kOutOfBounds;
   }
   DoRegisterSharedIdsCHROMIUM(namespace_id, n, ids);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoClear(GLbitfield mask) {
   if (CheckFramebufferComplete("glClear")) {
+    ApplyDirtyState();
     glClear(mask);
   }
 }
 
 void GLES2DecoderImpl::DoDrawArrays(
     GLenum mode, GLint first, GLsizei count) {
   if (!CheckFramebufferComplete("glDrawArrays")) {
     return;
   }
   // We have to check this here because the prototype for glDrawArrays
   // is GLint not GLsizei.
   if (first < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArrays: first < 0");
     return;
   }
 
   if (count == 0) {
     return;
   }
 
   GLuint max_vertex_accessed = first + count - 1;
   if (IsDrawValid(max_vertex_accessed)) {
     bool simulated_attrib_0 = SimulateAttrib0(max_vertex_accessed);
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
+      ApplyDirtyState();
       glDrawArrays(mode, first, count);
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
       RestoreStateForSimulatedAttrib0();
@@ skipping 28 matching lines @@
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachRenderbuffer(attachment, info);
     if (service_id == 0 ||
         glCheckFramebufferStatusEXT(target) == GL_FRAMEBUFFER_COMPLETE) {
       if (info) {
         ClearUnclearedRenderbuffers(target, framebuffer_info);
       }
     }
   }
+  if (framebuffer_info == bound_draw_framebuffer_) {
+    state_dirty_ = true;
+  }
 }
 
 void GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
   switch (cap) {
     case GL_SCISSOR_TEST:
       enable_scissor_test_ = enabled;
       break;
     default:
       break;
   }
@@ skipping 27 matching lines @@
   clear_stencil_ = s;
   glClearStencil(s);
 }
 
 void GLES2DecoderImpl::DoColorMask(
     GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
   mask_red_ = red;
   mask_green_ = green;
   mask_blue_ = blue;
   mask_alpha_ = alpha;
-  glColorMask(red, green, blue, alpha);
+  state_dirty_ = true;
 }
 
 void GLES2DecoderImpl::DoDepthMask(GLboolean depth) {
   mask_depth_ = depth;
-  glDepthMask(depth);
+  state_dirty_ = true;
 }
 
 void GLES2DecoderImpl::DoStencilMask(GLuint mask) {
   mask_stencil_front_ = mask;
   mask_stencil_back_ = mask;
-  glStencilMask(mask);
+  state_dirty_ = true;
 }
 
 void GLES2DecoderImpl::DoStencilMaskSeparate(GLenum face, GLuint mask) {
-  if (face == GL_FRONT) {
+  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
     mask_stencil_front_ = mask;
-  } else {
+  }
+  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
     mask_stencil_back_ = mask;
   }
-  glStencilMaskSeparate(face, mask);
+  state_dirty_ = true;
 }
 
 // NOTE: There's an assumption here that Texture attachments
 // are cleared because they are textures so we only need to clear
 // the renderbuffers.
 void GLES2DecoderImpl::ClearUnclearedRenderbuffers(
     GLenum target, FramebufferManager::FramebufferInfo* info) {
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     // TODO(gman): bind this to the DRAW point, clear then bind back to READ
   }
@@ skipping 24 matching lines @@
   info->MarkAttachedRenderbuffersAsCleared();
 
   RestoreClearState();
 
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     // TODO(gman): rebind draw.
   }
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
+  state_dirty_ = true;
   glClearColor(clear_red_, clear_green_, clear_blue_, clear_alpha_);
-  glColorMask(mask_red_, mask_green_, mask_blue_, mask_alpha_);
   glClearStencil(clear_stencil_);
-  glStencilMaskSeparate(GL_FRONT, mask_stencil_front_);
-  glStencilMaskSeparate(GL_BACK, mask_stencil_back_);
   glClearDepth(clear_depth_);
-  glDepthMask(mask_depth_);
   if (enable_scissor_test_) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   FramebufferManager::FramebufferInfo* info =
       GetFramebufferInfoForTarget(target);
   if (!info) {
     return GL_FRAMEBUFFER_COMPLETE;
@@ skipping 25 matching lines @@
   CopyRealGLErrorsToWrapper();
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachTexture(attachment, info, textarget, level);
     if (service_id != 0 &&
         glCheckFramebufferStatusEXT(target) == GL_FRAMEBUFFER_COMPLETE) {
       ClearUnclearedRenderbuffers(target, framebuffer_info);
     }
   }
+  if (framebuffer_info == bound_draw_framebuffer_) {
+    state_dirty_ = true;
+  }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferAttachmentParameteriv: no framebuffer bound");
     return;
@@ skipping 775 matching lines @@
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElements: range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(max_vertex_accessed)) {
     bool simulated_attrib_0 = SimulateAttrib0(max_vertex_accessed);
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
+      ApplyDirtyState();
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       glDrawElements(mode, count, type, indices);
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
@@ skipping 1195 matching lines @@
                "glTexImage2D: unknown texture for target");
     return error::kNoError;
   }
   scoped_array<int8> zero;
   if (!pixels) {
     zero.reset(new int8[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     pixels = zero.get();
   }
 
+  if (info->IsAttachedToFramebuffer()) {
+    state_dirty_ = true;
+  }
+
   if (!teximage2d_faster_than_texsubimage2d_) {
     GLsizei tex_width = 0;
     GLsizei tex_height = 0;
     GLenum tex_type = 0;
     GLenum tex_format = 0;
     if (info->GetLevelSize(target, level, &tex_width, &tex_height) &&
         info->GetLevelType(target, level, &tex_type, &tex_format) &&
         width == tex_width && height == tex_height &&
         type == tex_type && format == tex_format) {
       glTexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
@@ skipping 160 matching lines @@
 
   if ((channels_needed & channels_exist) != channels_needed) {
     SetGLError(GL_INVALID_OPERATION, "glCopyTexImage2D: incompatible format");
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   ScopedResolvedFrameBufferBinder binder(this, false);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
+  if (info->IsAttachedToFramebuffer()) {
+    state_dirty_ = true;
+  }
+
   // Clip to size to source dimensions
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (copyX != x ||
       copyY != y ||
@@ skipping 790 matching lines @@
   return error::kNoError;
 }
 
 // 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu