Add reference-counting for mailbox textures.

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2012 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/texture_manager.h"
 #include "base/bits.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
@@ skipping 97 matching lines @@
       owned_(true),
       stream_texture_(false),
       immutable_(false),
       estimated_size_(0) {
   if (manager_) {
     manager_->StartTracking(this);
   }
 }
 
 Texture::~Texture() {
+  DCHECK(!owned_ || !mailbox_);
+  if (mailbox_ && mailbox_->HasOneRef()) {

[apatrick_chromium, 2013/03/19 18:50:18]

HasOneRef is a bit dangerous if there are potentially ever going to be other
scoped_refptrs to TextureDefinition.

+    bool have_context = manager_ && manager_->have_context_;
+    if (have_context) {
+      GLuint id = mailbox_->ReleaseServiceId();
+      glDeleteTextures(1, &id);
+    }
+  }
+
   if (manager_) {
     if (owned_ && manager_->have_context_) {
       GLuint id = service_id();
       glDeleteTextures(1, &id);
     }
     MarkAsDeleted();
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
@@ skipping 796 matching lines @@
   num_uncleared_mips_ += texture->num_uncleared_mips();
   if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 TextureDefinition* TextureManager::Save(Texture* texture) {
-  DCHECK(texture->owned_);
+  DCHECK(texture->owned_ || texture->mailbox_);
 
   if (texture->IsAttachedToFramebuffer())
     return NULL;
 
   TextureDefinition::LevelInfos level_infos(texture->level_infos_.size());
   for (size_t face = 0; face < level_infos.size(); ++face) {
     GLenum target = texture->target() == GL_TEXTURE_2D ?
         GL_TEXTURE_2D : FaceIndexToGLTarget(face);
     for (size_t level = 0; level < texture->level_infos_[face].size();
          ++level) {
       const Texture::LevelInfo& level_info =
           texture->level_infos_[face][level];
       level_infos[face].push_back(
           TextureDefinition::LevelInfo(target,
                                        level_info.internal_format,
                                        level_info.width,
                                        level_info.height,
                                        level_info.depth,
                                        level_info.border,
                                        level_info.format,
                                        level_info.type,
                                        level_info.cleared));
-
-      SetLevelInfo(texture,
-                   target,
-                   level,
-                   GL_RGBA,
-                   0,
-                   0,
-                   0,
-                   0,
-                   GL_RGBA,
-                   GL_UNSIGNED_BYTE,
-                   true);
-    }
+   }
   }
 
-  GLuint old_service_id = texture->service_id();
   bool immutable = texture->IsImmutable();
 
-  GLuint new_service_id = 0;
-  glGenTextures(1, &new_service_id);
-  texture->SetServiceId(new_service_id);
-  texture->SetImmutable(false);
-
-  return new TextureDefinition(texture->target(),
-                               old_service_id,
-                               texture->min_filter(),
-                               texture->mag_filter(),
-                               texture->wrap_s(),
-                               texture->wrap_t(),
-                               texture->usage(),
-                               immutable,
-                               level_infos);
+  texture->mailbox_ = new TextureDefinition(texture->target(),
+                                   texture->service_id(),
+                                   texture->min_filter(),

[apatrick_chromium, 2013/03/19 18:50:18]

indentation

[no sievers, 2013/04/02 03:07:20]

Done.

+                                   texture->mag_filter(),
+                                   texture->wrap_s(),
+                                   texture->wrap_t(),
+                                   texture->usage(),
+                                   immutable,
+                                   level_infos);
+  texture->SetImmutable(true);
+  texture->SetNotOwned();
+  return texture->mailbox_;
 }
 
 bool TextureManager::Restore(
     const char* function_name,
     GLES2Decoder* decoder,
     Texture* texture,
     TextureDefinition* definition) {
-  DCHECK(texture->owned_);
-
-  scoped_ptr<TextureDefinition> scoped_definition(definition);
-
   if (texture->IsAttachedToFramebuffer())
     return false;
 
   if (texture->target() != definition->target())
     return false;
 
   if (texture->level_infos_.size() != definition->level_infos().size())
     return false;
 
   if (texture->level_infos_[0].size() != definition->level_infos()[0].size())
@@ skipping 14 matching lines @@
                    level_info.height,
                    level_info.depth,
                    level_info.border,
                    level_info.format,
                    level_info.type,
                    level_info.cleared);
     }
   }
 
   GLuint old_service_id = texture->service_id();
-  glDeleteTextures(1, &old_service_id);
-  texture->SetServiceId(definition->ReleaseServiceId());
-  glBindTexture(texture->target(), texture->service_id());
+  if (texture->mailbox_ && texture->mailbox_->HasOneRef()) {
+    GLuint id = texture->mailbox_->ReleaseServiceId();
+    DCHECK(id == old_service_id);
+  }
+  texture->mailbox_ = definition;
+
+  if (old_service_id != definition->service_id()) {
+    glDeleteTextures(1, &old_service_id);
+    texture->SetServiceId(definition->service_id());
+    glBindTexture(texture->target(), texture->service_id());
+    SetParameter(function_name, decoder, texture, GL_TEXTURE_MIN_FILTER,
+                 definition->min_filter());
+    SetParameter(function_name, decoder, texture, GL_TEXTURE_MAG_FILTER,
+                 definition->mag_filter());
+    SetParameter(function_name, decoder, texture, GL_TEXTURE_WRAP_S,
+                 definition->wrap_s());
+    SetParameter(function_name, decoder, texture, GL_TEXTURE_WRAP_T,
+                 definition->wrap_t());
+    if (feature_info_->validators()->texture_parameter.IsValid(
+        GL_TEXTURE_USAGE_ANGLE)) {
+      SetParameter(function_name, decoder, texture, GL_TEXTURE_USAGE_ANGLE,
+                   definition->usage());
+    }
+  }
+
+  texture->SetNotOwned();
   texture->SetImmutable(definition->immutable());
-  SetParameter(function_name, decoder, texture, GL_TEXTURE_MIN_FILTER,
-               definition->min_filter());
-  SetParameter(function_name, decoder, texture, GL_TEXTURE_MAG_FILTER,
-               definition->mag_filter());
-  SetParameter(function_name, decoder, texture, GL_TEXTURE_WRAP_S,
-               definition->wrap_s());
-  SetParameter(function_name, decoder, texture, GL_TEXTURE_WRAP_T,
-               definition->wrap_t());
-  if (feature_info_->validators()->texture_parameter.IsValid(
-      GL_TEXTURE_USAGE_ANGLE)) {
-    SetParameter(function_name, decoder, texture, GL_TEXTURE_USAGE_ANGLE,
-                 definition->usage());
-  }
 
   return true;
 }
 
 void TextureManager::SetParameter(
     const char* function_name, GLES2Decoder* decoder,
     Texture* texture, GLenum pname, GLint param) {
   DCHECK(decoder);
   DCHECK(texture);
   if (!texture->CanRender(feature_info_)) {
@@ skipping 164 matching lines @@
 void TextureManager::AddToSignature(
     Texture* texture,
     GLenum target,
     GLint level,
     std::string* signature) const {
   texture->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
 }  // namespace gles2
 }  // namespace gpu