exo: Implement zcr_linux_explicit_synchronization_v1

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>
@@ skipping 10 matching lines @@
 #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 "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_fence.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace exo {
 namespace {
 
 // The amount of time before we wait for release queries using
 // GetQueryObjectuivEXT(GL_QUERY_RESULT_EXT).
 const int kWaitForReleaseDelayMs = 500;
 
 GLenum GLInternalFormat(gfx::BufferFormat format) {
@@ skipping 70 matching lines @@
 
   // Allow texture to be reused after |sync_token| has passed and runs
   // |callback|.
   void Release(const base::Closure& callback,
                const gpu::SyncToken& sync_token,
                bool is_lost);
 
   // Binds the contents referenced by |image_id_| to the texture returned by
   // mailbox(). Returns a sync token that can be used when accessing texture
   // from a different context.
-  gpu::SyncToken BindTexImage();
+  gpu::SyncToken BindTexImage(std::unique_ptr<gfx::GpuFence> acquire_fence);
 
   // Releases the contents referenced by |image_id_| after |sync_token| has
   // passed and runs |callback| when completed.
   void ReleaseTexImage(const base::Closure& callback,
                        const gpu::SyncToken& sync_token,
                        bool is_lost);
 
   // Copy the contents of texture to |destination| and runs |callback| when
   // completed. Returns a sync token that can be used when accessing texture
   // from a different context.
-  gpu::SyncToken CopyTexImage(Texture* destination,
+  gpu::SyncToken CopyTexImage(std::unique_ptr<gfx::GpuFence> acquire_fence,
+                              Texture* destination,
                               const base::Closure& callback);
 
   // Returns the mailbox for this texture.
   gpu::Mailbox mailbox() const { return mailbox_; }
 
  private:
   void DestroyResources();
   void ReleaseWhenQueryResultIsAvailable(const base::Closure& callback);
   void Released();
   void ScheduleWaitForRelease(base::TimeDelta delay);
@@ skipping 81 matching lines @@
     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();
 }
 
-gpu::SyncToken Buffer::Texture::BindTexImage() {
+gpu::SyncToken Buffer::Texture::BindTexImage(std::unique_ptr<gfx::GpuFence> acquire_fence) {
   gpu::SyncToken sync_token;
   if (context_provider_) {
+    GLuint fence_id = 0;
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     gles2->ActiveTexture(GL_TEXTURE0);
     gles2->BindTexture(texture_target_, texture_id_);
     DCHECK_NE(image_id_, 0u);
-    gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_, 0);
+    if (acquire_fence) {
+      fence_id = glCreateFenceCHROMIUM(acquire_fence->AsClientFence());

[reveman, 2016/10/09 19:03:16]

Please use gles2->CreateFenceCHROMIUM here and it looks like we're leaking this
fence. Maybe make fence_id a member variable and call DestroyFenceCHROMIUM in
Texture::ReleaseTexImage and DestroyResources().

FYI, deferring it instead of destroying it right away might be better as destroy
requires some synchronization overhead to ensure it doesn't happen before usage
by (BindTexImage2DCHROMIUM) has taken place and it can be avoided if deferred
until after we produced and frame and been forced to flush anyhow.

[fooishbar, 2016/10/12 15:41:55]

Oops, yes. Where would we defer it though? I can have a probe at this a little
later, for v3 perhaps.

+      DCHECK_NE(fence_id, 0u);
+    }
+    gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_, fence_id);
     // Generate a crypto-secure random mailbox name if not already done.
     if (mailbox_.IsZero())
       CreateGLTextureMailbox(gles2, texture_id_, texture_target_, &mailbox_);
     // Create and return a sync token that can be used to ensure that the
     // BindTexImage2DCHROMIUM call is processed before issuing any commands
     // that will read from the texture on a different context.
     uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
     gles2->OrderingBarrierCHROMIUM();
     gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
   }
@@ skipping 17 matching lines @@
     // handled if sync token has data and buffer has been used. If buffer was
     // never used then run the callback immediately.
     if (sync_token.HasData()) {
       ReleaseWhenQueryResultIsAvailable(callback);
       return;
     }
   }
   callback.Run();
 }
 
-gpu::SyncToken Buffer::Texture::CopyTexImage(Texture* destination,
+gpu::SyncToken Buffer::Texture::CopyTexImage(std::unique_ptr<gfx::GpuFence> acquire_fence,
+                                             Texture* destination,
                                              const base::Closure& callback) {
   gpu::SyncToken sync_token;
   if (context_provider_) {
+    GLuint fence_id = 0;
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     gles2->ActiveTexture(GL_TEXTURE0);
     gles2->BindTexture(texture_target_, texture_id_);
     DCHECK_NE(image_id_, 0u);
-    gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_, 0);
+    if (acquire_fence) {
+      fence_id = glCreateFenceCHROMIUM(acquire_fence->AsClientFence());

[reveman, 2016/10/09 19:03:16]

ditto

+      DCHECK_NE(fence_id, 0u);
+    }
+    gles2->BindTexImage2DCHROMIUM(texture_target_, image_id_, fence_id);
     gles2->CopyTextureCHROMIUM(texture_id_, destination->texture_id_,
                                internalformat_, GL_UNSIGNED_BYTE, false, false,
                                false);
     DCHECK_NE(query_id_, 0u);
     gles2->BeginQueryEXT(query_type_, query_id_);
     gles2->ReleaseTexImage2DCHROMIUM(texture_target_, image_id_);
     gles2->EndQueryEXT(query_type_);
     // Run callback when query result is available and ReleaseTexImage has been
     // handled.
     ReleaseWhenQueryResultIsAvailable(callback);
@@ skipping 95 matching lines @@
     : 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,
+    std::unique_ptr<gfx::GpuFence> acquire_fence,
     bool secure_output_only,
     bool client_usage) {
   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
@@ skipping 30 matching lines @@
     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();
+    gpu::SyncToken sync_token = texture->BindTexImage(std::move(acquire_fence));
 
     *texture_mailbox =
         cc::TextureMailbox(texture->mailbox(), sync_token, texture_target_,
                            gpu_memory_buffer_->GetSize(), is_overlay_candidate_,
                            secure_output_only);
     // 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_))));
   }
 
   // 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(
+  gpu::SyncToken sync_token = contents_texture->CopyTexImage(std::move(acquire_fence),
       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);
   // 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),
@@ skipping 51 matching lines @@
 }
 
 void Buffer::ReleaseContentsTexture(std::unique_ptr<Texture> texture) {
   TRACE_EVENT0("exo", "Buffer::ReleaseContentsTexture");
 
   contents_texture_ = std::move(texture);
   Release();
 }
 
 }  // namespace exo