Make shader and program object lifetimes match OpenGL ES spec....

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 832 matching lines @@
     GLenum type,
     const void * data);
 
   // Creates a ProgramInfo for the given program.
   void CreateProgramInfo(GLuint client_id, GLuint service_id) {
     program_manager()->CreateProgramInfo(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   ProgramManager::ProgramInfo* GetProgramInfo(GLuint client_id) {
-    ProgramManager::ProgramInfo* info =
-        program_manager()->GetProgramInfo(client_id);
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return program_manager()->GetProgramInfo(client_id);
   }
 
   // Gets the program info for the given program. If it's not a program
   // generates a GL error. Returns NULL if not program.
   ProgramManager::ProgramInfo* GetProgramInfoNotShader(
       GLuint client_id, const char* function_name) {
     ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
     if (!info) {
       if (GetShaderInfo(client_id)) {
         SetGLError(GL_INVALID_OPERATION,
                    (std::string(function_name) +
                     ": shader passed for program").c_str());
       } else {
         SetGLError(GL_INVALID_VALUE,
                    (std::string(function_name) + ": unknown program").c_str());
       }
     }
     return info;
   }
 
 
-  // Deletes the program info for the given program.
-  void RemoveProgramInfo(GLuint client_id) {
-    program_manager()->RemoveProgramInfo(client_id);
-  }
-
   // Creates a ShaderInfo for the given shader.
   void CreateShaderInfo(GLuint client_id,
                         GLuint service_id,
                         GLenum shader_type) {
     shader_manager()->CreateShaderInfo(client_id, service_id, shader_type);
   }
 
   // Gets the shader info for the given shader. Returns NULL if none exists.
   ShaderManager::ShaderInfo* GetShaderInfo(GLuint client_id) {
-    ShaderManager::ShaderInfo* info =
-        shader_manager()->GetShaderInfo(client_id);
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return shader_manager()->GetShaderInfo(client_id);
   }
 
   // Gets the shader info for the given shader. If it's not a shader generates a
   // GL error. Returns NULL if not shader.
   ShaderManager::ShaderInfo* GetShaderInfoNotProgram(
       GLuint client_id, const char* function_name) {
     ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
     if (!info) {
       if (GetProgramInfo(client_id)) {
         SetGLError(
             GL_INVALID_OPERATION,
             (std::string(function_name) +
              ": program passed for shader").c_str());
       } else {
         SetGLError(GL_INVALID_VALUE,
                    (std::string(function_name) + ": unknown shader").c_str());
       }
     }
     return info;
   }
 
-  // Deletes the shader info for the given shader.
-  void RemoveShaderInfo(GLuint client_id) {
-    shader_manager()->RemoveShaderInfo(client_id);
-  }
-
   // Creates a buffer info for the given buffer.
   void CreateBufferInfo(GLuint client_id, GLuint service_id) {
     return buffer_manager()->CreateBufferInfo(client_id, service_id);
   }
 
   // Gets the buffer info for the given buffer.
   BufferManager::BufferInfo* GetBufferInfo(GLuint client_id) {
     BufferManager::BufferInfo* info =
         buffer_manager()->GetBufferInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
@@ skipping 1537 matching lines @@
   return false;
 }
 
 void GLES2DecoderImpl::Destroy() {
   bool have_context = context_.get() && MakeCurrent();
 
   if (group_.get())
     group_->set_have_context(have_context);
 
   if (have_context) {
+    if (current_program_) {
+      program_manager()->UnuseProgram(shader_manager(), current_program_);
+      current_program_ = NULL;
+    }
+
     if (attrib_0_buffer_id_) {
       glDeleteBuffersARB(1, &attrib_0_buffer_id_);
     }
     if (fixed_attrib_buffer_id_) {
       glDeleteBuffersARB(1, &fixed_attrib_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.
@@ skipping 663 matching lines @@
   glBindAttribLocation(info->service_id(), index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteShader(
     uint32 immediate_data_size, const gles2::DeleteShader& c) {
   GLuint client_id = c.shader;
   if (client_id) {
     ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
     if (info) {
-      glDeleteShader(info->service_id());
-      RemoveShaderInfo(client_id);
+      if (!info->IsDeleted()) {
+        glDeleteShader(info->service_id());
+        shader_manager()->MarkAsDeleted(info);
+      }
     } else {
       SetGLError(GL_INVALID_VALUE, "glDeleteShader: unknown shader");
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteProgram(
     uint32 immediate_data_size, const gles2::DeleteProgram& c) {
   GLuint client_id = c.program;
   if (client_id) {
     ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
     if (info) {
-      glDeleteProgram(info->service_id());
-      RemoveProgramInfo(client_id);
+      if (!info->IsDeleted()) {
+        glDeleteProgram(info->service_id());
+        program_manager()->MarkAsDeleted(shader_manager(), info);
+      }
     } else {
       SetGLError(GL_INVALID_VALUE, "glDeleteProgram: unknown program");
     }
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoDeleteSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
   IdAllocator* id_allocator = group_->GetIdAllocator(namespace_id);
@@ skipping 501 matching lines @@
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteriv: unknown texture");
   } else {
     texture_manager()->SetParameter(feature_info_, info, pname, *params);
     glTexParameteriv(target, pname, params);
   }
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
-  if (!current_program_ || current_program_->IsDeleted()) {
+  if (!current_program_) {
       // The program does not exist.
       SetGLError(GL_INVALID_OPERATION,
                  (std::string(function_name) + ": no program in use").c_str());
       return false;
   }
-  if (!current_program_->IsValid()) {
+  if (!current_program_->InUse()) {
     SetGLError(GL_INVALID_OPERATION,
                (std::string(function_name) + ": program not linked").c_str());
     return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgramForUniform(
     GLint location, const char* function_name) {
   if (!CheckCurrentProgram(function_name)) {
@@ skipping 112 matching lines @@
     if (!info) {
       return;
     }
     if (!info->IsValid()) {
       // Program was not linked successfully. (ie, glLinkProgram)
       SetGLError(GL_INVALID_OPERATION, "glUseProgram: program not linked");
       return;
     }
     service_id = info->service_id();
   }
+  if (current_program_) {
+    program_manager()->UnuseProgram(shader_manager(), current_program_);
+  }
   current_program_ = info;
+  if (current_program_) {
+    program_manager()->UseProgram(current_program_);
+  }
   glUseProgram(service_id);
 }
 
 GLenum GLES2DecoderImpl::GetGLError() {
   // Check the GL error first, then our wrapped error.
   GLenum error = glGetError();
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
         error = GLES2Util::GLErrorBitToGLError(mask);
@@ skipping 26 matching lines @@
 
 void GLES2DecoderImpl::ClearRealGLErrors() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
     NOTREACHED() << "GL error " << error << " was unhandled.";
   }
 }
 
 bool GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures() {
   DCHECK(current_program_);
-  DCHECK(!current_program_->IsDeleted());
   // Only check if there are some unrenderable textures.
   if (!texture_manager()->HaveUnrenderableTextures()) {
     return false;
   }
   bool textures_set = false;
   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]);
@@ skipping 16 matching lines @@
         }
       }
       // else: should this be an error?
     }
   }
   return textures_set;
 }
 
 void GLES2DecoderImpl::RestoreStateForNonRenderableTextures() {
   DCHECK(current_program_);
-  DCHECK(!current_program_->IsDeleted());
   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];
@@ skipping 15 matching lines @@
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
 }
 
 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_ || current_program_->IsDeleted()) {
+  if (!current_program_) {
     // The program does not exist.
     // But GL says no ERROR.
     return false;
   }
   // Validate all attribs currently enabled. If they are used by the current
   // program then check that they have enough elements to handle the draw call.
   // If they are not used by the current program check that they have a buffer
   // assigned.
   const VertexAttribManager::VertexAttribInfoList& infos =
       vertex_attrib_manager_.GetEnabledVertexAttribInfos();
@@ skipping 443 matching lines @@
   ProgramManager::ProgramInfo* program_info = GetProgramInfoNotShader(
       program_client_id, "glAttachShader");
   if (!program_info) {
     return;
   }
   ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
       shader_client_id, "glAttachShader");
   if (!shader_info) {
     return;
   }
-  if (!program_info->AttachShader(shader_info)) {
+  if (!program_info->AttachShader(shader_manager(), shader_info)) {
     SetGLError(GL_INVALID_OPERATION,
                "glAttachShader: can not attach more than"
                " one shader of the same type.");
     return;
   }
   glAttachShader(program_info->service_id(), shader_info->service_id());
 }
 
 void GLES2DecoderImpl::DoDetachShader(
     GLuint program_client_id, GLint shader_client_id) {
   ProgramManager::ProgramInfo* program_info = GetProgramInfoNotShader(
       program_client_id, "glDetachShader");
   if (!program_info) {
     return;
   }
   ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
       shader_client_id, "glDetachShader");
   if (!shader_info) {
     return;
   }
-  program_info->DetachShader(shader_info);
   glDetachShader(program_info->service_id(), shader_info->service_id());
+  program_info->DetachShader(shader_manager(), shader_info);
 }
 
 void GLES2DecoderImpl::DoValidateProgram(GLuint program_client_id) {
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program_client_id, "glValidateProgram");
   if (!info) {
     return;
   }
   if (!info->CanLink()) {
     info->set_log_info("Missing Shader");
@@ skipping 1541 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