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

gpu/command_buffer/service/program_manager.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/program_manager.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
 
 ProgramManager::ProgramInfo::UniformInfo::~UniformInfo() {}
 
 bool ProgramManager::IsInvalidPrefix(const char* name, size_t length) {
   static const char kInvalidPrefix[] = { 'g', 'l', '_' };
   return (length >= sizeof(kInvalidPrefix) &&
       memcmp(name, kInvalidPrefix, sizeof(kInvalidPrefix)) == 0);
 }
 
 ProgramManager::ProgramInfo::ProgramInfo(GLuint service_id)
-    : max_attrib_name_length_(0),
+    : use_count_(0),
+      max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       service_id_(service_id),
       valid_(false) {
 }
 
 void ProgramManager::ProgramInfo::Reset() {
   valid_ = false;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
@@ skipping 291 matching lines @@
         glGetProgramiv(service_id_, pname, params);
       }
       break;
     default:
       glGetProgramiv(service_id_, pname, params);
       break;
   }
 }
 
 bool ProgramManager::ProgramInfo::AttachShader(
+    ShaderManager* shader_manager,
     ShaderManager::ShaderInfo* info) {
+  DCHECK(shader_manager);
+  DCHECK(info);
   int index = ShaderTypeToIndex(info->shader_type());
   if (attached_shaders_[index] != NULL) {
     return false;
   }
   attached_shaders_[index] = ShaderManager::ShaderInfo::Ref(info);
+  shader_manager->UseShader(info);
   return true;
 }
 
 void ProgramManager::ProgramInfo::DetachShader(
+    ShaderManager* shader_manager,
     ShaderManager::ShaderInfo* info) {
+  DCHECK(shader_manager);
+  DCHECK(info);
   attached_shaders_[ShaderTypeToIndex(info->shader_type())] = NULL;
+  shader_manager->UnuseShader(info);
+}
+
+void ProgramManager::ProgramInfo::DetachShaders(ShaderManager* shader_manager) {
+  DCHECK(shader_manager);
+  for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
+    if (attached_shaders_[ii]) {
+      DetachShader(shader_manager, attached_shaders_[ii]);
+    }
+  }
 }
 
 bool ProgramManager::ProgramInfo::CanLink() const {
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
     if (!attached_shaders_[ii] || !attached_shaders_[ii]->IsValid()) {
       return false;
     }
   }
   return true;
 }
@@ skipping 25 matching lines @@
           std::make_pair(client_id,
                          ProgramInfo::Ref(new ProgramInfo(service_id))));
   DCHECK(result.second);
 }
 
 ProgramManager::ProgramInfo* ProgramManager::GetProgramInfo(GLuint client_id) {
   ProgramInfoMap::iterator it = program_infos_.find(client_id);
   return it != program_infos_.end() ? it->second : NULL;
 }
 
-void ProgramManager::RemoveProgramInfo(GLuint client_id) {
-  ProgramInfoMap::iterator it = program_infos_.find(client_id);
-  if (it != program_infos_.end()) {
-    it->second->MarkAsDeleted();
-    program_infos_.erase(it);
-  }
-}
-
 bool ProgramManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (ProgramInfoMap::const_iterator it = program_infos_.begin();
        it != program_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
+void ProgramManager::RemoveProgramInfoIfUnused(
+    ShaderManager* shader_manager, ProgramInfo* info) {
+  DCHECK(shader_manager);
+  DCHECK(info);
+  if (info->IsDeleted() && !info->InUse()) {
+    info->DetachShaders(shader_manager);
+    for (ProgramInfoMap::iterator it = program_infos_.begin();
+         it != program_infos_.end(); ++it) {
+      if (it->second->service_id() == info->service_id()) {
+        program_infos_.erase(it);
+        return;
+      }
+    }
+    NOTREACHED();
+  }
+}
+
+void ProgramManager::MarkAsDeleted(
+    ShaderManager* shader_manager,
+    ProgramManager::ProgramInfo* info) {
+  DCHECK(shader_manager);
+  DCHECK(info);
+  info->MarkAsDeleted();
+  RemoveProgramInfoIfUnused(shader_manager, info);
+}
+
+void ProgramManager::UseProgram(ProgramManager::ProgramInfo* info) {
+  DCHECK(info);
+  info->IncUseCount();
+}
+
+void ProgramManager::UnuseProgram(
+    ShaderManager* shader_manager,
+    ProgramManager::ProgramInfo* info) {
+  DCHECK(shader_manager);
+  DCHECK(info);
+  info->DecUseCount();
+  RemoveProgramInfoIfUnused(shader_manager, info);
+}
+
 }  // namespace gles2
 }  // namespace gpu