exo::CompositorFrameSinkHolder's release callbacks hold ref

components/exo/buffer.cc

 // Copyright 2015 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 "components/exo/buffer.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/context_provider.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
+#include "components/exo/compositor_frame_sink_holder.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/aura/env.h"
 #include "ui/compositor/compositor.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace exo {
 namespace {
 
 // The amount of time before we wait for release queries using
@@ skipping 176 matching lines @@
   if (context_provider_) {
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     return gles2->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
   }
   return true;
 }
 
 void Buffer::Texture::Release(const base::Closure& callback,
                               const gpu::SyncToken& sync_token,
                               bool is_lost) {
+  printf("Buffer::Texture::Release()\n");
   if (context_provider_) {
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     if (sync_token.HasData())
       gles2->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   }
 
   // Run callback as texture can be reused immediately after waiting for sync
   // token.
   callback.Run();
 }
@@ skipping 15 matching lines @@
     uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
     gles2->OrderingBarrierCHROMIUM();
     gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
   }
   return sync_token;
 }
 
 void Buffer::Texture::ReleaseTexImage(const base::Closure& callback,
                                       const gpu::SyncToken& sync_token,
                                       bool is_lost) {
+  printf("Buffer::Texture::ReleaseTexImage()\n");
   if (context_provider_) {
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     if (sync_token.HasData())
       gles2->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
     gles2->ActiveTexture(GL_TEXTURE0);
     gles2->BindTexture(texture_target_, texture_id_);
     DCHECK_NE(query_id_, 0u);
     gles2->BeginQueryEXT(query_type_, query_id_);
     gles2->ReleaseTexImage2DCHROMIUM(texture_target_, image_id_);
     gles2->EndQueryEXT(query_type_);
@@ skipping 123 matching lines @@
                bool use_zero_copy,
                bool is_overlay_candidate)
     : gpu_memory_buffer_(std::move(gpu_memory_buffer)),
       texture_target_(texture_target),
       query_type_(query_type),
       use_zero_copy_(use_zero_copy),
       is_overlay_candidate_(is_overlay_candidate) {}
 
 Buffer::~Buffer() {}
 
-std::unique_ptr<cc::SingleReleaseCallback> Buffer::ProduceTextureMailbox(
-    cc::TextureMailbox* texture_mailbox,
+bool Buffer::ProduceTransferableResource(
+    CompositorFrameSinkHolder* compositor_frame_sink_holder,
+    cc::ResourceId resource_id,
     bool secure_output_only,
-    bool client_usage) {
+    bool client_usage,
+    cc::TransferableResource* resource) {
   DCHECK(attach_count_);
   DLOG_IF(WARNING, use_count_ && client_usage)
       << "Producing a texture mailbox for a buffer that has not been released";
 
   // Some clients think that they can reuse a buffer before it's released by
   // performing a fast blit into the buffer. This behavior is bad as it prevents
   // the client from knowing when the buffer is actually released (e.g. the
   // release notification for the previous use of buffer can arrive after the
   // buffer has been reused). We stop running the release callback when this
   // type of behavior is detected as having the buffer always be busy will
@@ skipping 11 matching lines @@
     texture_.reset();
 
   ui::ContextFactory* context_factory =
       aura::Env::GetInstance()->context_factory();
   // Note: This can fail if GPU acceleration has been disabled.
   scoped_refptr<cc::ContextProvider> context_provider =
       context_factory->SharedMainThreadContextProvider();
   if (!context_provider) {
     DLOG(WARNING) << "Failed to acquire a context provider";
     Release();  // Decrements the use count
-    return nullptr;
+    resource->id = 0;
+    resource->size = gfx::Size();
+    return false;
   }
 
+  // The reference to the CompositorFrameSinkHolder keeps it alive until a
+  // release callback is received.
+  compositor_frame_sink_holder_ = compositor_frame_sink_holder;
+
+  resource->id = resource_id;
+  resource->format = cc::RGBA_8888;
+  resource->filter = GL_LINEAR;
+  resource->size = gpu_memory_buffer_->GetSize();
+
   // Create a new image texture for |gpu_memory_buffer_| with |texture_target_|
   // if one doesn't already exist. The contents of this buffer are copied to
   // |texture| using a call to CopyTexImage.
   if (!contents_texture_) {
     contents_texture_ = base::MakeUnique<Texture>(
         context_factory, context_provider.get(), gpu_memory_buffer_.get(),
         texture_target_, query_type_);
   }
 
   if (use_zero_copy_) {
     // Zero-copy means using the contents texture directly.
     Texture* texture = contents_texture_.get();
 
     // This binds the latest contents of this buffer to |texture|.
-    gpu::SyncToken sync_token = texture->BindTexImage();
+    resource->mailbox_holder = gpu::MailboxHolder(
+        texture->mailbox(), texture->BindTexImage(), texture_target_);
 
-    *texture_mailbox =
-        cc::TextureMailbox(texture->mailbox(), sync_token, texture_target_,
-                           gpu_memory_buffer_->GetSize(), is_overlay_candidate_,
-                           secure_output_only);
+    resource->is_overlay_candidate = is_overlay_candidate_;
+
+    cc::ReleaseCallback cb =
+        base::Bind(&Buffer::Texture::ReleaseTexImage, base::Unretained(texture),
+                   base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
+                              base::Passed(&contents_texture_)));
     // The contents texture will be released when no longer used by the
     // compositor.
-    return cc::SingleReleaseCallback::Create(
-        base::Bind(&Buffer::Texture::ReleaseTexImage, base::Unretained(texture),
-                   base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
-                              base::Passed(&contents_texture_))));
+    compositor_frame_sink_holder_->SetResourceReleaseCallback(
+        resource_id, base::WrapUnique(&cb));
+    return true;
   }
 
   // Create a mailbox texture that we copy the buffer contents to.
   if (!texture_) {
     texture_ =
         base::MakeUnique<Texture>(context_factory, context_provider.get());
   }
 
   // Copy the contents of |contents_texture| to |texture| and produce a
   // texture mailbox from the result in |texture|.
   Texture* contents_texture = contents_texture_.get();
   Texture* texture = texture_.get();
 
   // The contents texture will be released when copy has completed.
-  gpu::SyncToken sync_token = contents_texture->CopyTexImage(
-      texture, base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
-                          base::Passed(&contents_texture_)));
-  *texture_mailbox =
-      cc::TextureMailbox(texture->mailbox(), sync_token, GL_TEXTURE_2D,
-                         gpu_memory_buffer_->GetSize(),
-                         false /* is_overlay_candidate */, secure_output_only);
+  resource->mailbox_holder = gpu::MailboxHolder(
+      texture->mailbox(),
+      contents_texture->CopyTexImage(
+          texture, base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
+                              base::Passed(&contents_texture_))),
+      GL_TEXTURE_2D);
+  resource->is_overlay_candidate = false;
+  cc::ReleaseCallback callback =
+      base::Bind(&Buffer::Texture::Release, base::Unretained(texture),
+                 base::Bind(&Buffer::ReleaseTexture, AsWeakPtr(),
+                            base::Passed(&texture_)));
   // The mailbox texture will be released when no longer used by the
   // compositor.
-  return cc::SingleReleaseCallback::Create(
-      base::Bind(&Buffer::Texture::Release, base::Unretained(texture),
-                 base::Bind(&Buffer::ReleaseTexture, AsWeakPtr(),
-                            base::Passed(&texture_))));
+  compositor_frame_sink_holder_->SetResourceReleaseCallback(
+      resource_id, base::WrapUnique(&callback));
+  return true;
 }
 
 void Buffer::OnAttach() {
   DLOG_IF(WARNING, attach_count_ > 0u)
       << "Reattaching a buffer that is already attached to another surface.";
   attach_count_++;
 }
 
 void Buffer::OnDetach() {
   DCHECK_GT(attach_count_, 0u);
@@ skipping 25 matching lines @@
   CheckReleaseCallback();
 }
 
 void Buffer::CheckReleaseCallback() {
   if (attach_count_ || use_count_)
     return;
 
   // Run release callback to notify the client that buffer has been released.
   if (!release_callback_.is_null())
     release_callback_.Run();
+
+  compositor_frame_sink_holder_ = nullptr;
 }
 
 void Buffer::ReleaseTexture(std::unique_ptr<Texture> texture) {
-  texture_ = std::move(texture);
+  printf("Buffer::ReleaseTexture()\n");
+  if (this)
+    texture_ = std::move(texture);
 }
 
 void Buffer::ReleaseContentsTexture(std::unique_ptr<Texture> texture) {
   TRACE_EVENT0("exo", "Buffer::ReleaseContentsTexture");
-
-  contents_texture_ = std::move(texture);
-  Release();
+  printf("Buffer::ReleaseContentsTexture()\n");
+  if (this) {
+    contents_texture_ = std::move(texture);
+    Release();
+  }
 }
 
 }  // namespace exo