Add reference-counting for mailbox textures.

gpu/command_buffer/service/texture_definition.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_definition.h"
+#include "gpu/command_buffer/service/gl_utils.h"
 
 namespace gpu {
 namespace gles2 {
 
+namespace {
+
+static const TextureDefinition::LevelInfo kEmptyLevel2D =
+    TextureDefinition::LevelInfo(GL_TEXTURE_2D,
+                                 GL_RGBA,
+                                 0,
+                                 0,
+                                 1,
+                                 0,
+                                 GL_RGBA,
+                                 GL_UNSIGNED_BYTE,
+                                 true);
+
+static const TextureDefinition::LevelInfos kEmpty2DLevelInfos =
+    TextureDefinition::LevelInfos(
+        1,
+        std::vector<TextureDefinition::LevelInfo>(1, kEmptyLevel2D));
+
+}  // anonymous namespace
+
+TextureDefinition TextureDefinition::kEmptyTexture2D =
+    TextureDefinition(GL_TEXTURE_2D,
+                      0,
+                      GL_LINEAR,
+                      GL_LINEAR,
+                      GL_CLAMP_TO_EDGE,
+                      GL_CLAMP_TO_EDGE,
+                      GL_NONE,
+                      true,
+                      kEmpty2DLevelInfos);
+
+// TODO: Remove before checkin... just for testing
+std::set<GLuint> TextureDefinition::shared_texture_ids_;
+
+void TextureDefinition::Client::StartUsingSharedTexture(
+    TextureDefinition* definition) const {
+  DCHECK(definition->active_clients_.find(this) ==
+             definition->active_clients_.end());
+  definition->active_clients_.insert(this);
+  if (definition->client_transferred_from_) {
+    bool deleted = definition->client_transferred_from_
+        ->StopUsingSharedTexture(definition, false);
+    DCHECK(!deleted);
+    definition->client_transferred_from_ = NULL;
+  }
+}
+
+bool TextureDefinition::Client::StopUsingSharedTexture(
+    TextureDefinition* definition,
+    bool delete_texture) const {
+  size_t num_erased = definition->active_clients_.erase(this);
+  DCHECK(num_erased);
+
+  if (definition->active_clients_.empty()) {
+    definition->ReleaseServiceId(delete_texture);
+    delete definition;
+    return true;
+  }
+
+  return false;
+}
+
+void TextureDefinition::Client::StartSharedTextureTransfer(
+    TextureDefinition* definition) const {
+  definition->client_transferred_from_ = this;
+}
+
 TextureDefinition::LevelInfo::LevelInfo(GLenum target,
                                         GLenum internal_format,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLint border,
                                         GLenum format,
                                         GLenum type,
                                         bool cleared)
     : target(target),
@@ skipping 29 matching lines @@
                                      bool immutable,
                                      const LevelInfos& level_infos)
     : target_(target),
       service_id_(service_id),
       min_filter_(min_filter),
       mag_filter_(mag_filter),
       wrap_s_(wrap_s),
       wrap_t_(wrap_t),
       usage_(usage),
       immutable_(immutable),
-      level_infos_(level_infos) {
+      level_infos_(level_infos),
+      client_transferred_from_(NULL) {
+  DCHECK(shared_texture_ids_.find(service_id) == shared_texture_ids_.end());
+  if (service_id)
+    shared_texture_ids_.insert(service_id);
 }
 
 TextureDefinition::~TextureDefinition() {
+  FOR_EACH_OBSERVER(Observer, observers_, OnDestroySharedTexture(this));
   DCHECK_EQ(0U, service_id_) << "TextureDefinition leaked texture.";
 }
 
-GLuint TextureDefinition::ReleaseServiceId() {
+GLuint TextureDefinition::ReleaseServiceId(bool delete_texture) {
+  if (service_id_)
+    shared_texture_ids_.erase(service_id_);
+
   GLuint service_id = service_id_;
+  if (delete_texture)
+    glDeleteTextures(1, &service_id);
   service_id_ = 0;
   return service_id;
 }
 
+void TextureDefinition::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void TextureDefinition::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 }  // namespace gles2
 }  // namespace gpu