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"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
-#include "gpu/command_buffer/service/texture_definition.h"
 
 namespace gpu {
 namespace gles2 {
 
 static size_t GLTargetToFaceIndex(GLenum target) {
   switch (target) {
     case GL_TEXTURE_2D:
     case GL_TEXTURE_EXTERNAL_OES:
     case GL_TEXTURE_RECTANGLE_ARB:
       return 0;
@@ skipping 77 matching lines @@
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       max_level_set_(-1),
       texture_complete_(false),
       cube_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
       owned_(true),
       stream_texture_(false),
       immutable_(false),
-      estimated_size_(0) {
+      estimated_size_(0),
+      shared_texture_(NULL) {
   if (manager_) {
     manager_->StartTracking(this);
   }
 }
 
 Texture::~Texture() {
+  if (shared_texture_) {
+    bool have_context = manager_ && manager_->have_context_;
+    owned_ = shared_texture_->service_id() != service_id();
+    StopUsingSharedTexture(have_context);
+  }
+
   if (manager_) {
     if (owned_ && manager_->have_context_) {
       GLuint id = service_id();
       glDeleteTextures(1, &id);
     }
     MarkAsDeleted();
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
@@ skipping 559 matching lines @@
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     if (info.target != 0) {
       return info.image;
     }
   }
   return 0;
 }
 
+
+void Texture::StartUsingSharedTexture(TextureDefinition* definition) {
+  shared_texture_ = definition;
+  TextureDefinition::Client::StartUsingSharedTexture(definition);
+}
+
+bool Texture::StopUsingSharedTexture(bool have_context) {
+  bool was_deleted = TextureDefinition::Client::StopUsingSharedTexture(
+      shared_texture_, have_context);
+  shared_texture_ = NULL;
+  return was_deleted;
+}
+
 TextureManager::TextureManager(
     MemoryTracker* memory_tracker,
     FeatureInfo* feature_info,
     GLint max_texture_size,
     GLint max_cube_map_texture_size)
     : memory_tracker_managed_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
       memory_tracker_unmanaged_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
       feature_info_(feature_info),
@@ skipping 219 matching lines @@
     ++num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 TextureDefinition* TextureManager::Save(Texture* texture) {
   DCHECK(texture->owned_);
 
+  // Fail if we are not the current owner of the shared texture.
+  if (texture->shared_texture_ &&
+      texture->shared_texture_->service_id() != texture->service_id())
+    return NULL;
+
   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_CUBE_MAP ? FaceIndexToGLTarget(face)
                                                  : texture->target();
     for (GLint level = 0; level <= texture->max_level_set_; ++level) {
       const Texture::LevelInfo& level_info =
@@ skipping 23 matching lines @@
                    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);
+  texture->SetImmutable(true);
 
-  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);
+  if (!texture->shared_texture_) {
+    texture->StartUsingSharedTexture(
+        new TextureDefinition(texture->target(),
+                              old_service_id,
+                              texture->min_filter(),
+                              texture->mag_filter(),
+                              texture->wrap_s(),
+                              texture->wrap_t(),
+                              texture->usage(),
+                              immutable,
+                              level_infos));
+  }
+  return texture->shared_texture_;
 }
 
 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 18 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());
+
+  // We don't allow real sharing (yet), so we can't already be using the same
+  // texture.
+  DCHECK(definition->service_id() != old_service_id);
+
+  if (texture->shared_texture_ && texture->shared_texture_ != definition) {
+    // We were already referencing a texture, and it's different from the one we
+    // are consuming now.
+    bool owned = texture->shared_texture_->service_id() != old_service_id;
+    if (owned)
+      glDeleteTextures(1, &old_service_id);
+    texture->StopUsingSharedTexture(true);
+  } else {
+    glDeleteTextures(1, &old_service_id);
+  }
+
+  if (!texture->shared_texture_)
+    texture->StartUsingSharedTexture(definition);
+
+  texture->SetServiceId(definition->service_id());
   glBindTexture(texture->target(), texture->service_id());
   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());
@@ skipping 179 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