Defer clearing textures and renderbuffers

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 335 matching lines @@
   // Create a new frame buffer.
   void Create();
 
   // Attach a color render buffer to a frame buffer.
   void AttachRenderTexture(Texture* texture);
 
   // Attach a render buffer to a frame buffer. Note that this unbinds any
   // currently bound frame buffer.
   void AttachRenderBuffer(GLenum target, RenderBuffer* render_buffer);
 
-  // Clear the given attached buffers.
-  void Clear(GLbitfield buffers);
-
   // Destroy the frame buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
   // Invalidate the frame buffer. This can be used when a context is lost and it
   // is not possible to make it current in order to free the resource.
   void Invalidate();
 
   // See glCheckFramebufferStatusEXT.
   GLenum CheckStatus();
@@ skipping 136 matching lines @@
   virtual bool SetParent(GLES2Decoder* parent_decoder,
                          uint32 parent_texture_id);
   virtual bool ResizeOffscreenFrameBuffer(const gfx::Size& size);
   void UpdateParentTextureInfo();
   virtual bool MakeCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
   virtual gfx::GLSurface* GetGLSurface() { return surface_.get(); }
   virtual ContextGroup* GetContextGroup() { return group_.get(); }
 
+  virtual void SetGLError(GLenum error, const char* msg);
   virtual void SetResizeCallback(Callback1<gfx::Size>::Type* callback);
 
 #if defined(OS_MACOSX)
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
 #endif
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager);
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id);
 
@@ skipping 312 matching lines @@
     const std::string& name_str);
 
   error::Error GetUniformLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str);
 
   // Helper for glShaderSource.
   error::Error ShaderSourceHelper(
       GLuint client_id, const char* data, uint32 data_size);
 
-  // Clears any uncleared render buffers attached to the given frame buffer.
-  void ClearUnclearedRenderbuffers(
+  // Clear any textures used by the current program.
+  bool ClearUnclearedTextures();
+
+  // Clear any uncleared level in texture.
+  // Returns false if there was a generated GL error.
+  bool ClearTexture(TextureManager::TextureInfo* info);
+
+  // Clears any uncleared attachments attached to the given frame buffer.
+  // Returns false if there was a generated GL error.
+  void ClearUnclearedAttachments(
       GLenum target, FramebufferManager::FramebufferInfo* info);
 
+  // overridden from GLES2Decoder
+  virtual bool ClearLevel(
+      unsigned service_id,
+      unsigned bind_target,
+      unsigned target,
+      int level,
+      unsigned format,
+      unsigned type,
+      int width,
+      int height);
+
   // Restore all GL state that affects clearing.
   void RestoreClearState();
 
   // Remembers the state of some capabilities.
   // Returns: true if glEnable/glDisable should actually be called.
   bool SetCapabilityState(GLenum cap, bool enabled);
 
-  // Check that the current frame buffer is complete. Generates error if not.
-  bool CheckFramebufferComplete(const char* func_name);
+  // Check that the currently bound framebuffers are valid.
+  // Generates GL error if not.
+  bool CheckBoundFramebuffersValid(const char* func_name);
+
+  // Check if a framebuffer meets our requirements.
+  bool CheckFramebufferValid(
+      FramebufferManager::FramebufferInfo* framebuffer,
+      GLenum target,
+      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
   // -1. If the current program is not valid generates the appropriate GL
   // error. Returns true if the current program is in a usable state and
   // location is not -1.
@@ skipping 211 matching lines @@
   // false if pname is unknown.
   bool GetNumValuesReturnedForGLGet(GLenum pname, GLsizei* num_values);
 
   // Gets the GLError through our wrapper.
   GLenum GetGLError();
 
   // Gets the GLError and stores it in our wrapper. Effectively
   // this lets us peek at the error without losing it.
   GLenum PeekGLError();
 
-  // Sets our wrapper for the GLError.
-  void SetGLError(GLenum error, const char* msg);
-
   // Copies the real GL errors to the wrapper. This is so we can
   // make sure there are no native GL errors before calling some GL function
   // so that on return we know any error generated was for that specific
   // command.
   void CopyRealGLErrorsToWrapper();
 
   // Clear all real GL errors. This is to prevent the client from seeing any
   // errors caused by GL calls that it was not responsible for issuing.
   void ClearRealGLErrors();
 
@@ skipping 72 matching lines @@
       case GL_READ_FRAMEBUFFER:
         info = bound_read_framebuffer_;
         break;
       default:
         NOTREACHED();
         break;
     }
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
+  RenderbufferManager::RenderbufferInfo* GetRenderbufferInfoForTarget(
+      GLenum target) {
+    RenderbufferManager::RenderbufferInfo* info = NULL;
+    switch (target) {
+      case GL_RENDERBUFFER:
+        info = bound_renderbuffer_;
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+    return (info && !info->IsDeleted()) ? info : NULL;
+  }
+
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
   // should be called.
   bool GetUniformSetup(
       GLuint program, GLint location,
       uint32 shm_id, uint32 shm_offset,
       error::Error* error, GLuint* service_id, void** result,
       GLenum* result_type);
 
   // Returns true if the context was just lost due to e.g. GL_ARB_robustness.
@@ skipping 463 matching lines @@
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   GLuint attach_id = render_buffer ? render_buffer->id() : 0;
   glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
                                target,
                                GL_RENDERBUFFER,
                                attach_id);
 }
 
-void FrameBuffer::Clear(GLbitfield buffers) {
-  ScopedGLErrorSuppressor suppressor(decoder_);
-  ScopedFrameBufferBinder binder(decoder_, id_);
-  glClear(buffers);
-}
-
 void FrameBuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteFramebuffersEXT(1, &id_);
     id_ = 0;
   }
 }
 
 void FrameBuffer::Invalidate() {
   id_ = 0;
@@ skipping 532 matching lines @@
   bool result = context_.get() ? context_->MakeCurrent(surface_.get()) : false;
   if (result && WasContextLost()) {
     LOG(ERROR) << "  GLES2DecoderImpl: Context lost during MakeCurrent.";
     result = false;
   }
 
   return result;
 }
 
 void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
+  RenderbufferManager::RenderbufferInfo* renderbuffer =
+      GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   glBindRenderbufferEXT(
-      GL_RENDERBUFFER,
-      bound_renderbuffer_ ? bound_renderbuffer_->service_id() : 0);
+      GL_RENDERBUFFER, renderbuffer ? 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();
@@ skipping 28 matching lines @@
   if (info.bound_texture_2d) {
     last_id = info.bound_texture_2d->service_id();
   } else {
     last_id = 0;
   }
 
   glBindTexture(GL_TEXTURE_2D, last_id);
   glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
 }
 
-bool GLES2DecoderImpl::CheckFramebufferComplete(const char* func_name) {
-  if (bound_draw_framebuffer_ && bound_draw_framebuffer_->IsNotComplete()) {
-    SetGLError(GL_INVALID_FRAMEBUFFER_OPERATION,
-               (std::string(func_name) + " framebuffer incomplete").c_str());
+bool GLES2DecoderImpl::CheckFramebufferValid(
+    FramebufferManager::FramebufferInfo* framebuffer,
+    GLenum target, const char* func_name) {
+  if (!framebuffer || framebuffer->IsDeleted()) {
+    return true;
+  }
+
+  GLenum completeness = framebuffer->IsPossiblyComplete();
+  if (completeness != GL_FRAMEBUFFER_COMPLETE) {
+    SetGLError(
+        GL_INVALID_FRAMEBUFFER_OPERATION,
+        (std::string(func_name) + " framebuffer incomplete").c_str());
     return false;
   }
+
+  // Are all the attachments cleared?
+  if (renderbuffer_manager()->HaveUnclearedRenderbuffers() ||
+      texture_manager()->HaveUnclearedMips()) {
+    if (!framebuffer->IsCleared()) {
+      // Can we clear them?
+      if (glCheckFramebufferStatusEXT(target) != GL_FRAMEBUFFER_COMPLETE) {
+        SetGLError(
+            GL_INVALID_FRAMEBUFFER_OPERATION,
+            (std::string(func_name) +
+            " framebuffer incomplete (clear)").c_str());
+        return false;
+      }
+      ClearUnclearedAttachments(target, framebuffer);
+    }
+  }
+
+  // NOTE: At this point we don't know if the framebuffer is complete but
+  // we DO know that everything that needs to be cleared has been cleared.
   return true;
 }
 
+bool GLES2DecoderImpl::CheckBoundFramebuffersValid(const char* func_name) {
+  if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
+    return CheckFramebufferValid(
+        bound_draw_framebuffer_, GL_FRAMEBUFFER_EXT, func_name);
+  }
+  return CheckFramebufferValid(
+             bound_draw_framebuffer_, GL_DRAW_FRAMEBUFFER_EXT, func_name) &&
+         CheckFramebufferValid(
+             bound_read_framebuffer_, GL_READ_FRAMEBUFFER_EXT, func_name);
+}
+
 gfx::Size GLES2DecoderImpl::GetBoundReadFrameBufferSize() {
-  if (bound_read_framebuffer_ != 0) {
+  FramebufferManager::FramebufferInfo* framebuffer =
+      GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+  if (framebuffer != NULL) {
     const FramebufferManager::FramebufferInfo::Attachment* attachment =
-        bound_read_framebuffer_->GetAttachment(GL_COLOR_ATTACHMENT0);
+        framebuffer->GetAttachment(GL_COLOR_ATTACHMENT0);
     if (attachment) {
       return gfx::Size(attachment->width(), attachment->height());
     }
     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) {
-    return bound_read_framebuffer_->GetColorAttachmentFormat();
+  FramebufferManager::FramebufferInfo* framebuffer =
+      GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+  if (framebuffer != NULL) {
+    return 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();
+  FramebufferManager::FramebufferInfo* framebuffer =
+      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  if (framebuffer != NULL) {
+    return framebuffer->GetColorAttachmentFormat();
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_color_format_;
   } else {
     return back_buffer_color_format_;
   }
 }
 
 void GLES2DecoderImpl::UpdateParentTextureInfo() {
   if (parent_) {
     // Update the info about the offscreen saved color texture in the parent.
@@ skipping 10 matching lines @@
         feature_info_,
         info,
         GL_TEXTURE_2D,
         0,  // level
         GL_RGBA,
         offscreen_size_.width(),
         offscreen_size_.height(),
         1,  // depth
         0,  // border
         GL_RGBA,
-        GL_UNSIGNED_BYTE);
+        GL_UNSIGNED_BYTE,
+        true);
     parent_texture_manager->SetParameter(
         feature_info_,
         info,
         GL_TEXTURE_MAG_FILTER,
         GL_NEAREST);
     parent_texture_manager->SetParameter(
         feature_info_,
         info,
         GL_TEXTURE_MIN_FILTER,
         GL_NEAREST);
@@ skipping 440 matching lines @@
   }
   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();
+  FramebufferManager::FramebufferInfo* framebuffer =
+      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  if (framebuffer) {
+    return 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();
+  FramebufferManager::FramebufferInfo* framebuffer =
+      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  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() {
   if (state_dirty_) {
@@ skipping 382 matching lines @@
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_FRAMEBUFFER_BINDING:
     // case GL_DRAW_FRAMEBUFFER_BINDING_EXT: (same as GL_FRAMEBUFFER_BINDING)
       *num_written = 1;
       if (params) {
-        if (bound_draw_framebuffer_) {
+        FramebufferManager::FramebufferInfo* framebuffer =
+            GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+        if (framebuffer) {
           GLuint client_id = 0;
           framebuffer_manager()->GetClientId(
-              bound_draw_framebuffer_->service_id(), &client_id);
+              framebuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_READ_FRAMEBUFFER_BINDING:
       *num_written = 1;
       if (params) {
-        if (bound_read_framebuffer_) {
+        FramebufferManager::FramebufferInfo* framebuffer =
+            GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+        if (framebuffer) {
           GLuint client_id = 0;
           framebuffer_manager()->GetClientId(
-              bound_read_framebuffer_->service_id(), &client_id);
+              framebuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_RENDERBUFFER_BINDING:
       *num_written = 1;
       if (params) {
-        if (bound_renderbuffer_) {
+        RenderbufferManager::RenderbufferInfo* renderbuffer =
+            GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
+        if (renderbuffer) {
           GLuint client_id = 0;
           renderbuffer_manager()->GetClientId(
-              bound_renderbuffer_->service_id(), &client_id);
+              renderbuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_CURRENT_PROGRAM:
       *num_written = 1;
       if (params) {
         if (current_program_) {
@@ skipping 297 matching lines @@
     return error::kNoError;
   }
   if (ids == NULL) {
     return error::kOutOfBounds;
   }
   DoRegisterSharedIdsCHROMIUM(namespace_id, n, ids);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoClear(GLbitfield mask) {
-  if (CheckFramebufferComplete("glClear")) {
+  if (CheckBoundFramebuffersValid("glClear")) {
     ApplyDirtyState();
     glClear(mask);
   }
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
     GLuint client_renderbuffer_id) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
@@ skipping 12 matching lines @@
       return;
     }
     service_id = info->service_id();
   }
   CopyRealGLErrorsToWrapper();
   glFramebufferRenderbufferEXT(
       target, attachment, renderbuffertarget, service_id);
   GLenum error = PeekGLError();
   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;
   }
 }
 
 bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
   switch (cap) {
     case GL_SCISSOR_TEST:
       enable_scissor_test_ = enabled;
@@ skipping 70 matching lines @@
 void GLES2DecoderImpl::DoStencilMaskSeparate(GLenum face, GLuint mask) {
   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
     mask_stencil_front_ = mask;
   }
   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
     mask_stencil_back_ = 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(
+// Assumes framebuffer is complete.
+void GLES2DecoderImpl::ClearUnclearedAttachments(
     GLenum target, FramebufferManager::FramebufferInfo* info) {
+  DCHECK(!info->IsDeleted());
   if (target == GL_READ_FRAMEBUFFER_EXT) {
-    // TODO(gman): bind this to the DRAW point, clear then bind back to READ
+    // bind this to the DRAW point, clear then bind back to READ
+    // TODO(gman): I don't think there is any guarantee that an FBO that
+    //   is complete on the READ attachment will be complete as a DRAW
+    //   attachment.
+    glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
+    glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, info->service_id());
   }
   GLbitfield clear_bits = 0;
   if (info->HasUnclearedAttachment(GL_COLOR_ATTACHMENT0)) {
     glClearColor(
-        0, 0, 0,
+        0.0f, 0.0f, 0.0f,
         (GLES2Util::GetChannelsForFormat(
-             info->GetColorAttachmentFormat()) & 0x0008) != 0 ? 0 : 1);
+             info->GetColorAttachmentFormat()) & 0x0008) != 0 ? 0.0f : 1.0f);
     glColorMask(true, true, true, true);
     clear_bits |= GL_COLOR_BUFFER_BIT;
   }
 
   if (info->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT) ||
       info->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
     glClearStencil(0);
     glStencilMask(-1);
     clear_bits |= GL_STENCIL_BUFFER_BIT;
   }
 
   if (info->HasUnclearedAttachment(GL_DEPTH_ATTACHMENT) ||
       info->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
     glClearDepth(1.0f);
     glDepthMask(true);
     clear_bits |= GL_DEPTH_BUFFER_BIT;
   }
 
   glDisable(GL_SCISSOR_TEST);
   glClear(clear_bits);
 
-  info->MarkAttachedRenderbuffersAsCleared();
+  info->MarkAttachmentsAsCleared(renderbuffer_manager(), texture_manager());
 
   RestoreClearState();
 
   if (target == GL_READ_FRAMEBUFFER_EXT) {
-    // TODO(gman): rebind draw.
+    glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, info->service_id());
+    FramebufferManager::FramebufferInfo*framebuffer =
+        GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+    glBindFramebufferEXT(
+        GL_DRAW_FRAMEBUFFER_EXT, framebuffer ? framebuffer->service_id() : 0);
   }
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
   state_dirty_ = true;
   glClearColor(clear_red_, clear_green_, clear_blue_, clear_alpha_);
   glClearStencil(clear_stencil_);
   glClearDepth(clear_depth_);
   if (enable_scissor_test_) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
-  FramebufferManager::FramebufferInfo* info =
+  FramebufferManager::FramebufferInfo* framebuffer =
       GetFramebufferInfoForTarget(target);
-  if (!info) {
+  if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
+  GLenum completeness = framebuffer->IsPossiblyComplete();
+  if (completeness != GL_FRAMEBUFFER_COMPLETE) {
+    return completeness;
+  }
   return glCheckFramebufferStatusEXT(target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferTexture2D: no framebuffer bound.");
     return;
   }
   GLuint service_id = 0;
   TextureManager::TextureInfo* info = NULL;
   if (client_texture_id) {
     info = GetTextureInfo(client_texture_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
                  "glFramebufferTexture2D: unknown texture");
       return;
     }
     service_id = info->service_id();
   }
+
+  if (!texture_manager()->ValidForTarget(
+      feature_info_, textarget, level, 0, 0, 1)) {
+    SetGLError(GL_INVALID_VALUE,
+               "glFramebufferTexture2D: level out of range");
+    return;
+  }
+
   CopyRealGLErrorsToWrapper();
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   GLenum error = PeekGLError();
   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);
@@ skipping 19 matching lines @@
       }
       default:
         break;
     }
     *params = client_id;
   }
 }
 
 void GLES2DecoderImpl::DoGetRenderbufferParameteriv(
     GLenum target, GLenum pname, GLint* params) {
-  if (!bound_renderbuffer_) {
+  RenderbufferManager::RenderbufferInfo* renderbuffer =
+      GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
+  if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
                "glGetRenderbufferParameteriv: no renderbuffer bound");
     return;
   }
   switch (pname) {
   case GL_RENDERBUFFER_INTERNAL_FORMAT:
-    *params = bound_renderbuffer_->internal_format();
+    *params = renderbuffer->internal_format();
     break;
   case GL_RENDERBUFFER_WIDTH:
-    *params = bound_renderbuffer_->width();
+    *params = renderbuffer->width();
     break;
   case GL_RENDERBUFFER_HEIGHT:
-    *params = bound_renderbuffer_->height();
+    *params = renderbuffer->height();
     break;
   default:
     glGetRenderbufferParameterivEXT(target, pname, params);
     break;
   }
 }
 
 void GLES2DecoderImpl::DoBlitFramebufferEXT(
     GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
     GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
@@ skipping 13 matching lines @@
 
 void GLES2DecoderImpl::DoRenderbufferStorageMultisample(
     GLenum target, GLsizei samples, GLenum internalformat,
     GLsizei width, GLsizei height) {
   if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
     SetGLError(GL_INVALID_OPERATION,
                "glRenderbufferStorageMultisampleEXT: function not available");
     return;
   }
 
+  RenderbufferManager::RenderbufferInfo* renderbuffer =
+      GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
+  if (!renderbuffer) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glGetRenderbufferStorageMultisample: no renderbuffer bound");
+    return;
+  }
+
   if (samples > renderbuffer_manager()->max_samples()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetRenderbufferStorageMultisample: samples too large");
     return;
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetRenderbufferStorageMultisample: size too large");
@@ skipping 19 matching lines @@
   CopyRealGLErrorsToWrapper();
   if (IsAngle()) {
     glRenderbufferStorageMultisampleANGLE(
         target, samples, impl_format, width, height);
   } else {
     glRenderbufferStorageMultisampleEXT(
         target, samples, impl_format, width, height);
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
-    bound_renderbuffer_->SetInfo(samples, internalformat, width, height);
+    renderbuffer_manager()->SetInfo(
+        renderbuffer, samples, internalformat, width, height);
   }
 }
 
 void GLES2DecoderImpl::DoRenderbufferStorage(
   GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
-  if (!bound_renderbuffer_) {
+  RenderbufferManager::RenderbufferInfo* renderbuffer =
+      GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
+  if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
                "glGetRenderbufferStorage: no renderbuffer bound");
     return;
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetRenderbufferStorage: size too large");
     return;
@@ skipping 12 matching lines @@
       case GL_RGB565:
         impl_format = GL_RGB;
         break;
     }
   }
 
   CopyRealGLErrorsToWrapper();
   glRenderbufferStorageEXT(target, impl_format, width, height);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
-    bound_renderbuffer_->SetInfo(0, internalformat, width, height);
+    renderbuffer_manager()->SetInfo(
+        renderbuffer, 0, internalformat, width, height);
   }
 }
 
 void GLES2DecoderImpl::DoLinkProgram(GLuint program) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoLinkProgram");
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program, "glLinkProgram");
   if (!info) {
     return;
   }
@@ skipping 399 matching lines @@
           glBindTexture(texture_unit.bind_target,
                         texture_info ? texture_info->service_id() : 0);
         }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
 }
 
+bool GLES2DecoderImpl::ClearUnclearedTextures() {
+  // 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 (current_program_) {
+    const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
+       current_program_->sampler_indices();
+    for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
+      const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+          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 < group_->max_texture_units()) {
+          TextureUnit& texture_unit = texture_units_[texture_unit_index];
+          TextureManager::TextureInfo* texture_info =
+              texture_unit.GetInfoForSamplerType(uniform_info->type);
+          if (texture_info && !texture_info->SafeToRenderFrom()) {
+            if (!texture_manager()->ClearRenderableLevels(this, texture_info)) {
+              return false;
+            }
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
 bool GLES2DecoderImpl::IsDrawValid(GLuint max_vertex_accessed) {
   // NOTE: We specifically do not check current_program->IsValid() because
   // it could never be invalid since glUseProgram would have failed. While
   // glLinkProgram could later mark the program as invalid the previous
   // valid program will still function if it is still the current program.
   if (!current_program_) {
     // The program does not exist.
     // But GL says no ERROR.
     return false;
   }
@@ skipping 214 matching lines @@
   GLint first = static_cast<GLint>(c.first);
   GLsizei count = static_cast<GLsizei>(c.count);
   if (!validators_->draw_mode.IsValid(mode)) {
     SetGLError(GL_INVALID_ENUM, "glDrawArrays: mode GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArrays: count < 0");
     return error::kNoError;
   }
-  if (!CheckFramebufferComplete("glDrawArrays")) {
+  if (!CheckBoundFramebuffersValid("glDrawArrays")) {
     return error::kNoError;
   }
   // 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 error::kNoError;
   }
 
   if (count == 0) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed = first + count - 1;
   if (IsDrawValid(max_vertex_accessed)) {
+    if (!ClearUnclearedTextures()) {
+      SetGLError(GL_INVALID_VALUE, "glDrawArrays: out of memory");
+      return error::kNoError;
+    }
     bool simulated_attrib_0 = false;
     if (!SimulateAttrib0(max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
     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) {
@@ skipping 37 matching lines @@
   }
   if (!validators_->draw_mode.IsValid(mode)) {
     SetGLError(GL_INVALID_ENUM, "glDrawElements: mode GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->index_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glDrawElements: type GL_INVALID_ENUM");
     return error::kNoError;
   }
 
-  if (!CheckFramebufferComplete("glDrawElements")) {
+  if (!CheckBoundFramebuffersValid("glDrawElements")) {
     return error::kNoError;
   }
 
   if (count == 0) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
   if (!bound_element_array_buffer_->GetMaxValueForRange(
       offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElements: range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(max_vertex_accessed)) {
+    if (!ClearUnclearedTextures()) {
+      SetGLError(GL_INVALID_VALUE, "glDrawElements: out of memory");
+      return error::kNoError;
+    }
     bool simulated_attrib_0 = false;
     if (!SimulateAttrib0(max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
     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);
@@ skipping 662 matching lines @@
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFrameBufferSize();
 
   GLint max_x;
   GLint max_y;
   if (!SafeAdd(x, width, &max_x) || !SafeAdd(y, height, &max_y)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
     return error::kNoError;
   }
 
+  if (!CheckBoundFramebuffersValid("glReadPixels")) {
+    return error::kNoError;
+  }
+
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // The user requested an out of range area. Get the results 1 line
     // at a time.
     uint32 temp_size;
     if (!GLES2Util::ComputeImageDataSize(
         width, 1, format, type, pack_alignment_, &temp_size)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
       return error::kNoError;
     }
     GLsizei unpadded_row_size = temp_size;
@@ skipping 395 matching lines @@
     return;
   }
   if (bufferdata_faster_than_buffersubdata_ &&
       offset == 0 && size == info->size()) {
     glBufferData(target, size, data, info->usage());
     return;
   }
   glBufferSubData(target, offset, size, data);
 }
 
+bool GLES2DecoderImpl::ClearLevel(
+    unsigned service_id,
+    unsigned bind_target,
+    unsigned target,
+    int level,
+    unsigned format,
+    unsigned type,
+    int width,
+    int height) {
+  // Assumes the size has already been checked.
+  uint32 pixels_size = 0;
+  if (!GLES2Util::ComputeImageDataSize(
+      width, height, format, type, unpack_alignment_, &pixels_size)) {
+    return false;
+  }
+  scoped_array<char> zero(new char[pixels_size]);
+  memset(zero.get(), 0, pixels_size);
+  glBindTexture(bind_target, service_id);
+  WrappedTexImage2D(
+      target, level, format, width, height, 0, format, type, zero.get());
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(bind_target);
+  glBindTexture(bind_target, info ? info->service_id() : 0);
+  return true;
+}
+
 error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLsizei image_size,
   const void* data) {
   // TODO(gman): Validate image_size is correct for width, height and format.
@@ skipping 27 matching lines @@
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   CopyRealGLErrorsToWrapper();
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         feature_info_,
-        info, target, level, internal_format, width, height, 1, border, 0, 0);
+        info, target, level, internal_format, width, height, 1, border, 0, 0,
+        true);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
     uint32 immediate_data_size, const gles2::CompressedTexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
@@ skipping 155 matching lines @@
       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;
 
   if (level_is_same && !pixels) {
     tex_image_2d_failed_ = false;
     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_ && level_is_same) {
     glTexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
     tex_image_2d_failed_ = false;
     return error::kNoError;
   }
 
   CopyRealGLErrorsToWrapper();
   WrappedTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
-    texture_manager()->SetLevelInfo(feature_info_, info,
-        target, level, internal_format, width, height, 1, border, format, type);
+    texture_manager()->SetLevelInfo(
+        feature_info_, info,
+        target, level, internal_format, width, height, 1, border, format, type,
+        pixels != NULL);
     tex_image_2d_failed_ = false;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2D(
     uint32 immediate_data_size, const gles2::TexImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexImage2D");
   tex_image_2d_failed_ = true;
   GLenum target = static_cast<GLenum>(c.target);
@@ skipping 79 matching lines @@
         GL_INVALID_OPERATION,
         "glCompressdTexSubImage2D: format does not match internal format.");
     return;
   }
   if (!info->ValidForTexture(
       target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressdTexSubImage2D: bad dimensions.");
     return;
   }
+  // Note: There is no need to deal with texture cleared tracking here
+  // because the validation above means you can only get here if the level
+  // is already a matching compressed format and in that case
+  // CompressedTexImage2D already cleared the texture.
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, image_size, data);
 }
 
 static void Clip(
     GLint start, GLint range, GLint sourceRange,
     GLint* out_start, GLint* out_range) {
   DCHECK(out_start);
   DCHECK(out_range);
   if (start < 0) {
     range += start;
     start = 0;
   }
   GLint end = start + range;
   if (end > sourceRange) {
     range -= end - sourceRange;
   }
   *out_start = start;
   *out_range = range;
 }
 
-
 void GLES2DecoderImpl::DoCopyTexImage2D(
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLint x,
   GLint y,
   GLsizei width,
   GLsizei height,
   GLint border) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
@@ skipping 33 matching lines @@
   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 ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the texture.
-    uint32 pixels_size = 0;
-    if (!GLES2Util::ComputeImageDataSize(
-        width, height, internal_format, GL_UNSIGNED_BYTE,
-        unpack_alignment_, &pixels_size)) {
-      SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D: dimensions too large");
+    if (!ClearLevel(
+        info->service_id(), info->target(),
+        target, level, internal_format, GL_UNSIGNED_BYTE, width, height)) {
+      SetGLError(GL_OUT_OF_MEMORY, "glCopyTexImage2D: dimensions too big");
       return;
     }
-    scoped_array<char> zero(new char[pixels_size]);
-    memset(zero.get(), 0, pixels_size);
-    glTexImage2D(target, level, internal_format, width, height, 0,
-                 internal_format, GL_UNSIGNED_BYTE, zero.get());
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
     glCopyTexImage2D(target, level, internal_format,
                      copyX, copyY, copyWidth, copyHeight, border);
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         feature_info_, info, target, level, internal_format, width, height, 1,
-        border, internal_format, GL_UNSIGNED_BYTE);
+        border, internal_format, GL_UNSIGNED_BYTE, true);
   }
 }
 
 void GLES2DecoderImpl::DoCopyTexSubImage2D(
   GLenum target,
   GLint level,
   GLint xoffset,
   GLint yoffset,
   GLint x,
   GLint y,
@@ skipping 27 matching lines @@
   }
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
   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 (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+    SetGLError(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D: dimensions too big");
+    return;
+  }
+
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
-    // some part was clipped so clear the texture.
+    // some part was clipped so clear the sub rect.
     uint32 pixels_size = 0;
     if (!GLES2Util::ComputeImageDataSize(
         width, height, format, type, unpack_alignment_, &pixels_size)) {
       SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D: dimensions too large");
       return;
     }
     scoped_array<char> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
+
   if (copyHeight > 0 && copyWidth > 0) {
     GLint dx = copyX - x;
     GLint dy = copyY - y;
     GLint destX = xoffset + dx;
     GLint destY = yoffset + dy;
     glCopyTexSubImage2D(target, level,
                         destX, destY, copyX, copyY,
                         copyWidth, copyHeight);
   }
 }
@@ skipping 44 matching lines @@
   if (teximage2d_faster_than_texsubimage2d_ && xoffset == 0 && yoffset == 0) {
     GLsizei tex_width = 0;
     GLsizei tex_height = 0;
     bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
     DCHECK(ok);
     if (width == tex_width && height == tex_height) {
       // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
       // same as internal_foramt. If that changes we'll need to look them up.
       WrappedTexImage2D(
           target, level, format, width, height, 0, format, type, data);
+      texture_manager()->SetLevelCleared(info, target, level);
       return;
     }
   }
+  if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+    SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D: dimensions too big");
+    return;
+  }
   glTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, data);
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     uint32 immediate_data_size, const gles2::TexSubImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexSubImage2D");
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
@@ skipping 820 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