Add reference-counting for mailbox textures.

content/common/gpu/texture_image_transport_surface.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 "content/common/gpu/texture_image_transport_surface.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 12 matching lines @@
 using gpu::gles2::TextureDefinition;
 using gpu::gles2::TextureManager;
 
 namespace content {
 
 TextureImageTransportSurface::TextureImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     const gfx::GLSurfaceHandle& handle)
       : fbo_id_(0),
-        backbuffer_(CreateTextureDefinition(gfx::Size(), 0)),
+        backbuffer_(&TextureDefinition::kEmptyTexture2D),
         stub_destroyed_(false),
         backbuffer_suggested_allocation_(true),
         frontbuffer_suggested_allocation_(true),
         handle_(handle),
         is_swap_buffers_pending_(false),
         did_unschedule_(false) {
-  helper_.reset(new ImageTransportHelper(this,
-                                         manager,
-                                         stub,
-                                         gfx::kNullPluginWindow));
+  helper_.reset(
+      new ImageTransportHelper(this, manager, stub, gfx::kNullPluginWindow));
 }
 
 TextureImageTransportSurface::~TextureImageTransportSurface() {
   DCHECK(stub_destroyed_);
   Destroy();
 }
 
 bool TextureImageTransportSurface::Initialize() {
   mailbox_manager_ =
       helper_->stub()->decoder()->GetContextGroup()->mailbox_manager();
@@ skipping 46 matching lines @@
 }
 
 bool TextureImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (stub_destroyed_) {
     // Early-exit so that we don't recreate the fbo. We still want to return
     // true, so that the context is made current and the GLES2DecoderImpl can
     // release its own resources.
     return true;
   }
 
-  context_ = context;
-
   if (!fbo_id_) {
     glGenFramebuffersEXT(1, &fbo_id_);
     glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_id_);
     current_size_ = gfx::Size(1, 1);
     helper_->stub()->AddDestructionObserver(this);
   }
 
   // We could be receiving non-deferred GL commands, that is anything that does
   // not need a framebuffer.
   if (!backbuffer_->service_id() && !is_swap_buffers_pending_ &&
@@ skipping 84 matching lines @@
 
   DCHECK(backbuffer_size() == current_size_);
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.size = backbuffer_size();
   params.mailbox_name.assign(
       reinterpret_cast<const char*>(&mailbox_name_), sizeof(mailbox_name_));
 
   glFlush();
   ProduceTexture();
 
-  // Do not allow destruction while we are still waiting for a swap ACK,
-  // so we do not leak a texture in the mailbox.
-  AddRef();
-
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
 
   DCHECK(!is_swap_buffers_pending_);
   is_swap_buffers_pending_ = true;
   return true;
 }
 
 bool TextureImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(backbuffer_suggested_allocation_);
@@ skipping 17 matching lines @@
   params.x = x;
   params.y = y;
   params.width = width;
   params.height = height;
   params.mailbox_name.assign(
       reinterpret_cast<const char*>(&mailbox_name_), sizeof(mailbox_name_));
 
   glFlush();
   ProduceTexture();
 
-  // Do not allow destruction while we are still waiting for a swap ACK,
-  // so we do not leak a texture in the mailbox.
-  AddRef();
-
   helper_->SendAcceleratedSurfacePostSubBuffer(params);
 
   DCHECK(!is_swap_buffers_pending_);
   is_swap_buffers_pending_ = true;
   return true;
 }
 
 std::string TextureImageTransportSurface::GetExtensions() {
   std::string extensions = gfx::GLSurface::GetExtensions();
   extensions += extensions.empty() ? "" : " ";
@@ skipping 22 matching lines @@
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   if (params.sync_point == 0) {
     BufferPresentedImpl(params.mailbox_name);
   } else {
     helper_->manager()->sync_point_manager()->AddSyncPointCallback(
         params.sync_point,
         base::Bind(&TextureImageTransportSurface::BufferPresentedImpl,
                    this,
                    params.mailbox_name));
   }
-
-  // Careful, we might get deleted now if we were only waiting for
-  // a final swap ACK.
-  Release();
 }
 
 void TextureImageTransportSurface::BufferPresentedImpl(
     const std::string& mailbox_name) {
+  if (stub_destroyed_)
+    return;
+
   DCHECK(!backbuffer_->service_id());
   if (!mailbox_name.empty()) {
     DCHECK(mailbox_name.length() == GL_MAILBOX_SIZE_CHROMIUM);
     mailbox_name.copy(reinterpret_cast<char *>(&mailbox_name_),
                       sizeof(MailboxName));
     ConsumeTexture();
   }
 
-  if (stub_destroyed_ && backbuffer_->service_id()) {
-    // TODO(sievers): Remove this after changes to the mailbox to take ownership
-    // of the service ids.
-    DCHECK(context_.get() && surface_.get());
-    uint32 service_id = backbuffer_->ReleaseServiceId();
-    if (context_->MakeCurrent(surface_.get()))
-      glDeleteTextures(1, &service_id);
-
-    return;
-  }
-
   DCHECK(is_swap_buffers_pending_);
   is_swap_buffers_pending_ = false;
 
   // We should not have allowed the backbuffer to be discarded while the ack
   // was pending.
   DCHECK(backbuffer_suggested_allocation_);
 
   // We're relying on the fact that the parent context is
   // finished with it's context when it inserts the sync point that
   // triggers this callback.
@@ skipping 13 matching lines @@
 }
 
 void TextureImageTransportSurface::OnResizeViewACK() {
   NOTREACHED();
 }
 
 void TextureImageTransportSurface::ReleaseBackTexture() {
   if (!backbuffer_->service_id())
     return;
 
-  uint32 service_id = backbuffer_->ReleaseServiceId();
-  glDeleteTextures(1, &service_id);
-  backbuffer_.reset(CreateTextureDefinition(gfx::Size(), 0));
+  StopUsingSharedTexture(backbuffer_, true);
+  backbuffer_ = &TextureDefinition::kEmptyTexture2D;
   mailbox_name_ = MailboxName();
   glFlush();
   CHECK_GL_ERROR();
 }
 
 void TextureImageTransportSurface::CreateBackTexture() {
   // If |is_swap_buffers_pending| we are waiting for our backbuffer
   // in the mailbox, so we shouldn't be reallocating it now.
   DCHECK(!is_swap_buffers_pending_);
 
   if (backbuffer_->service_id() && backbuffer_size() == current_size_)
     return;
 
-  uint32 service_id = backbuffer_->ReleaseServiceId();
+  uint32 service_id = backbuffer_->service_id();
 
   VLOG(1) << "Allocating new backbuffer texture";
 
   // On Qualcomm we couldn't resize an FBO texture past a certain
   // size, after we allocated it as 1x1. So here we simply delete
   // the previous texture on resize, to insure we don't 'run out of
   // memory'.
   if (service_id &&
       helper_->stub()
              ->decoder()
              ->GetContextGroup()
              ->feature_info()
              ->workarounds()
              .delete_instead_of_resize_fbo) {
-    glDeleteTextures(1, &service_id);
+    StopUsingSharedTexture(backbuffer_, true);
+    backbuffer_ = NULL;
     service_id = 0;
     mailbox_name_ = MailboxName();
   }
 
   if (!service_id) {
     MailboxName new_mailbox_name;
     MailboxName& name = mailbox_name_;
     // This slot should be uninitialized.
     DCHECK(!memcmp(&name, &new_mailbox_name, sizeof(MailboxName)));
     mailbox_manager_->GenerateMailboxName(&new_mailbox_name);
     name = new_mailbox_name;
     glGenTextures(1, &service_id);
   }
 
-  backbuffer_.reset(
-      CreateTextureDefinition(current_size_, service_id));
+  if (!backbuffer_ || !backbuffer_->service_id()) {
+    backbuffer_ = CreateTextureDefinition(current_size_, service_id);
+    StartUsingSharedTexture(backbuffer_);
+  } else {
+    backbuffer_->level_infos()[0][0].width = current_size_.width();
+    backbuffer_->level_infos()[0][0].height = current_size_.height();
+  }
 
   {
     ScopedTextureBinder texture_binder(service_id);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
         current_size_.width(), current_size_.height(), 0,
         GL_RGBA, GL_UNSIGNED_BYTE, NULL);
@@ skipping 16 matching lines @@
 #ifndef NDEBUG
   GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
   if (status != GL_FRAMEBUFFER_COMPLETE) {
     DLOG(FATAL) << "Framebuffer incomplete: " << status;
   }
 #endif
 }
 
 TextureDefinition* TextureImageTransportSurface::CreateTextureDefinition(
     gfx::Size size, int service_id) {
+  DCHECK(service_id && !size.IsEmpty());
   TextureDefinition::LevelInfo info(
       GL_TEXTURE_2D, GL_RGBA, size.width(), size.height(), 1,
       0, GL_RGBA, GL_UNSIGNED_BYTE, true);
 
   TextureDefinition::LevelInfos level_infos;
   level_infos.resize(1);
   level_infos[0].resize(1);
   level_infos[0][0] = info;
   return new TextureDefinition(
       GL_TEXTURE_2D,
       service_id,
       GL_LINEAR,
       GL_LINEAR,
       GL_CLAMP_TO_EDGE,
       GL_CLAMP_TO_EDGE,
       GL_NONE,
       true,
       level_infos);
 }
 
 void TextureImageTransportSurface::ConsumeTexture() {
   DCHECK(!backbuffer_->service_id());
 
-  backbuffer_.reset(mailbox_manager_->ConsumeTexture(
-      GL_TEXTURE_2D, mailbox_name_));
+  backbuffer_ = mailbox_manager_->ConsumeTexture(GL_TEXTURE_2D, mailbox_name_);
   if (!backbuffer_) {
     mailbox_name_ = MailboxName();
-    backbuffer_.reset(CreateTextureDefinition(gfx::Size(), 0));
+    backbuffer_ = &TextureDefinition::kEmptyTexture2D;
+  } else {
+    StartUsingSharedTexture(backbuffer_);
   }
 }
 
 void TextureImageTransportSurface::ProduceTexture() {
   DCHECK(backbuffer_->service_id());
   DCHECK(!backbuffer_size().IsEmpty());
 
   // Pass NULL as |owner| here to avoid errors from glConsumeTextureCHROMIUM()
   // when the renderer context group goes away before the RWHV handles a pending
   // ACK. We avoid leaking a texture in the mailbox by waiting for the final ACK
   // at which point we consume the correct texture back.
   bool success = mailbox_manager_->ProduceTexture(
       GL_TEXTURE_2D,
       mailbox_name_,
-      backbuffer_.release(),
-      NULL);
+      backbuffer_,
+      std::make_pair(MailboxManager::TEXTURE_POOL_FOR_SURFACE,
+                     helper_->stub()->surface_id()));
+  bool deleted = StopUsingSharedTexture(backbuffer_, true);
+  DCHECK(!deleted);
   DCHECK(success);
   mailbox_name_ = MailboxName();
-  backbuffer_.reset(CreateTextureDefinition(gfx::Size(), 0));
+  backbuffer_ = &TextureDefinition::kEmptyTexture2D;
 }
 
 }  // namespace content