Saved offscreen textures are allocated GL_RGB when no alpha channel is reques...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2010 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 185 matching lines @@
   // Set the initial size and format of a render texture or resize it.
   bool AllocateStorage(const gfx::Size& size, GLenum format);
 
   // Copy the contents of the currently bound frame buffer.
   void Copy(const gfx::Size& size);
 
   // Destroy the render texture. This must be explicitly called before
   // destroying this object.
   void Destroy();
 
+  // Invalidate the texture. 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();
+
   GLuint id() const {
     return id_;
   }
 
   gfx::Size size() const {
     return size_;
   }
 
  private:
   GLES2DecoderImpl* decoder_;
@@ skipping 11 matching lines @@
   // Create a new render buffer.
   void Create();
 
   // Set the initial size and format of a render buffer or resize it.
   bool AllocateStorage(const gfx::Size& size, GLenum format, GLsizei samples);
 
   // Destroy the render buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
+  // Invalidate the render 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();
+
   GLuint id() const {
     return id_;
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(RenderBuffer);
 };
 
@@ skipping 13 matching lines @@
   // 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();
 
   GLuint id() const {
     return id_;
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   GLuint id_;
@@ skipping 1082 matching lines @@
   GLenum offscreen_target_depth_format_;
   GLenum offscreen_target_stencil_format_;
   GLsizei offscreen_target_samples_;
 
   GLuint copy_texture_to_parent_texture_fb_;
 
   // The copy that is saved when SwapBuffers is called.  It is also
   // used as the destination for multi-sample resolves.
   scoped_ptr<FrameBuffer> offscreen_saved_frame_buffer_;
   scoped_ptr<Texture> offscreen_saved_color_texture_;
+  GLenum offscreen_saved_color_format_;
 
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
 
   // The last error message set.
   std::string last_error_;
 
   // The current decoder error.
   error::Error current_decoder_error_;
 
   bool use_shader_translator_;
@@ skipping 151 matching lines @@
 }
 
 void Texture::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteTextures(1, &id_);
     id_ = 0;
   }
 }
 
+void Texture::Invalidate() {
+  id_ = 0;
+}
+
 RenderBuffer::RenderBuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       id_(0) {
 }
 
 RenderBuffer::~RenderBuffer() {
   // This does not destroy the render buffer because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
@@ skipping 33 matching lines @@
 }
 
 void RenderBuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteRenderbuffersEXT(1, &id_);
     id_ = 0;
   }
 }
 
+void RenderBuffer::Invalidate() {
+  id_ = 0;
+}
+
 FrameBuffer::FrameBuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       id_(0) {
 }
 
 FrameBuffer::~FrameBuffer() {
   // This does not destroy the frame buffer because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
@@ skipping 36 matching lines @@
 }
 
 void FrameBuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteFramebuffersEXT(1, &id_);
     id_ = 0;
   }
 }
 
+void FrameBuffer::Invalidate() {
+  id_ = 0;
+}
+
 GLenum FrameBuffer::CheckStatus() {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   return glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 }
 
 GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
   return new GLES2DecoderImpl(group);
 }
@@ skipping 19 matching lines @@
       clear_stencil_(0),
       mask_stencil_front_(-1),
       mask_stencil_back_(-1),
       clear_depth_(1.0f),
       mask_depth_(true),
       enable_scissor_test_(false),
       offscreen_target_color_format_(0),
       offscreen_target_depth_format_(0),
       offscreen_target_stencil_format_(0),
       offscreen_target_samples_(0),
+      offscreen_saved_color_format_(0),
       current_decoder_error_(error::kNoError),
       use_shader_translator_(true),
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()) {
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
 
   // The shader translator is not needed for EGL because it already uses the
@@ skipping 132 matching lines @@
         offscreen_target_depth_format_ = GL_DEPTH24_STENCIL8;
         offscreen_target_stencil_format_ = 0;
       } else {
         offscreen_target_depth_format_ = attrib_parser.depth_size_ > 0 ?
             GL_DEPTH_COMPONENT : 0;
         offscreen_target_stencil_format_ = attrib_parser.stencil_size_ > 0 ?
             GL_STENCIL_INDEX : 0;
       }
     }
 
+    offscreen_saved_color_format_ = attrib_parser.alpha_size_ > 0 ?
+        GL_RGBA : GL_RGB;
+
     // Create the target frame buffer. This is the one that the client renders
     // directly to.
     offscreen_target_frame_buffer_.reset(new FrameBuffer(this));
     offscreen_target_frame_buffer_->Create();
     // Due to GLES2 format limitations, either the color texture (for
     // non-multisampling) or the color render buffer (for multisampling) will be
     // attached to the offscreen frame buffer.  The render buffer has more
     // limited formats available to it, but the texture can't do multisampling.
     if (IsOffscreenBufferMultisampled()) {
       offscreen_target_color_render_buffer_.reset(new RenderBuffer(this));
@@ skipping 416 matching lines @@
     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();
   }
 
   if (parent_ || IsOffscreenBufferMultisampled()) {
-    offscreen_saved_color_texture_->AllocateStorage(pending_offscreen_size_,
-                                                    GL_RGBA);
+    DCHECK(offscreen_saved_color_format_);
+    offscreen_saved_color_texture_->AllocateStorage(
+        pending_offscreen_size_, offscreen_saved_color_format_);
 
     offscreen_saved_frame_buffer_->AttachRenderTexture(
         offscreen_saved_color_texture_.get());
     if (offscreen_saved_frame_buffer_->CheckStatus() !=
         GL_FRAMEBUFFER_COMPLETE) {
       LOG(ERROR) << "GLES2DecoderImpl::UpdateOffscreenFrameBufferSize failed "
                  << "because offscreen saved FBO was incomplete.";
       return false;
     }
   }
@@ skipping 45 matching lines @@
       texture_manager()->GetTextureInfo(client_texture_id);
   if (texture) {
     *service_texture_id = texture->service_id();
     return true;
   }
   return false;
 }
 
 void GLES2DecoderImpl::Destroy() {
   bool have_context = context_.get() && MakeCurrent();
-  group_->set_have_context(have_context);
+
+  if (group_.get())
+    group_->set_have_context(have_context);
+
   if (have_context) {
     if (attrib_0_buffer_id_) {
       glDeleteBuffersARB(1, &attrib_0_buffer_id_);
     }
 
     // Remove the saved frame buffer mapping from the parent decoder. The
     // parent pointer is a weak pointer so it will be null if the parent has
     // already been destroyed.
     if (parent_) {
       // First check the texture has been mapped into the parent. This might not
       // be the case if initialization failed midway through.
       GLuint service_id = offscreen_saved_color_texture_->id();
       GLuint client_id = 0;
       if (parent_->texture_manager()->GetClientId(service_id, &client_id)) {
         parent_->texture_manager()->RemoveTextureInfo(feature_info_, client_id);
       }
 
       glDeleteFramebuffersEXT(1, &copy_texture_to_parent_texture_fb_);
     }
 
-    if (offscreen_target_frame_buffer_.get()) {
+    if (offscreen_target_frame_buffer_.get())
       offscreen_target_frame_buffer_->Destroy();
-      offscreen_target_frame_buffer_.reset();
-    }
-
-    if (offscreen_target_color_texture_.get()) {
+    if (offscreen_target_color_texture_.get())
       offscreen_target_color_texture_->Destroy();
-      offscreen_target_color_texture_.reset();
-    }
-
-    if (offscreen_target_color_render_buffer_.get()) {
+    if (offscreen_target_color_render_buffer_.get())
       offscreen_target_color_render_buffer_->Destroy();
-      offscreen_target_color_render_buffer_.reset();
-    }
-
-    if (offscreen_target_depth_render_buffer_.get()) {
+    if (offscreen_target_depth_render_buffer_.get())
       offscreen_target_depth_render_buffer_->Destroy();
-      offscreen_target_depth_render_buffer_.reset();
-    }
-
-    if (offscreen_target_stencil_render_buffer_.get()) {
+    if (offscreen_target_stencil_render_buffer_.get())
       offscreen_target_stencil_render_buffer_->Destroy();
-      offscreen_target_stencil_render_buffer_.reset();
-    }
-
-    if (offscreen_saved_frame_buffer_.get()) {
+    if (offscreen_saved_frame_buffer_.get())
       offscreen_saved_frame_buffer_->Destroy();
-      offscreen_saved_frame_buffer_.reset();
-    }
-
-    if (offscreen_saved_color_texture_.get()) {
+    if (offscreen_saved_color_texture_.get())
       offscreen_saved_color_texture_->Destroy();
-      offscreen_saved_color_texture_.reset();
-    }
 
     // must release the ContextGroup before destroying the context as its
     // destructor uses GL.
     group_ = NULL;
 
     context_->Destroy();
     context_.reset();
+  } else {
+    if (offscreen_target_frame_buffer_.get())
+      offscreen_target_frame_buffer_->Invalidate();
+    if (offscreen_target_color_texture_.get())
+      offscreen_target_color_texture_->Invalidate();
+    if (offscreen_target_color_render_buffer_.get())
+      offscreen_target_color_render_buffer_->Invalidate();
+    if (offscreen_target_depth_render_buffer_.get())
+      offscreen_target_depth_render_buffer_->Invalidate();
+    if (offscreen_target_stencil_render_buffer_.get())
+      offscreen_target_stencil_render_buffer_->Invalidate();
+    if (offscreen_saved_frame_buffer_.get())
+      offscreen_saved_frame_buffer_->Invalidate();
+    if (offscreen_saved_color_texture_.get())
+      offscreen_saved_color_texture_->Invalidate();
   }
+
+  offscreen_target_frame_buffer_.reset();
+  offscreen_target_color_texture_.reset();
+  offscreen_target_color_render_buffer_.reset();
+  offscreen_target_depth_render_buffer_.reset();
+  offscreen_target_stencil_render_buffer_.reset();
+  offscreen_saved_frame_buffer_.reset();
+  offscreen_saved_color_texture_.reset();
 }
 
 void GLES2DecoderImpl::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
   // We can't resize the render buffers immediately because there might be a
   // partial frame rendered into them and we don't want the tail end of that
   // rendered into the reallocated storage. Defer until the next SwapBuffers.
   pending_offscreen_size_ = size;
 }
 
 void GLES2DecoderImpl::DoCopyTextureToParentTexture(
@@ skipping 3253 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