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 68 matching lines @@
   // Returns true if GLES2 resources for texture have been lost.
   bool IsLost();
 
   // 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();
+  // mailbox(), using the fence from |fence| for synchronization. Returns a
+  // sync token that can be used when accessing texture from a different
+  // context.
+  gpu::SyncToken BindTexImage(gfx::GpuFence* 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(gfx::GpuFence* 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);
   void WaitForRelease();
 
   ui::ContextFactory* context_factory_;
   scoped_refptr<cc::ContextProvider> context_provider_;
   const unsigned texture_target_;
   const unsigned query_type_;
   const GLenum internalformat_;
   unsigned image_id_ = 0;
   unsigned query_id_ = 0;
   unsigned texture_id_ = 0;
+  unsigned fence_id_ = 0;
   gpu::Mailbox mailbox_;
   base::Closure release_callback_;
   base::TimeTicks wait_for_release_time_;
   bool wait_for_release_pending_ = false;
   base::WeakPtrFactory<Texture> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 Buffer::Texture::Texture(ui::ContextFactory* context_factory,
@@ skipping 61 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(gfx::GpuFence* fence) {
   gpu::SyncToken sync_token;
   if (context_provider_) {
     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 (fence) {
+      fence_id_ = gles2->CreateFenceCHROMIUM(fence->AsClientFence());
+      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());
   }
   return sync_token;
 }
 
 void Buffer::Texture::ReleaseTexImage(const base::Closure& callback,
                                       const gpu::SyncToken& sync_token,
                                       bool is_lost) {
   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_);
+    if (fence_id_) {
+      gles2->DestroyFenceCHROMIUM(fence_id_);
+      fence_id_ = 0;
+    }
     gles2->EndQueryEXT(query_type_);
     // Run callback when query result is available and ReleaseTexImage has been
     // 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(gfx::GpuFence* fence,
+                                             Texture* destination,
                                              const base::Closure& callback) {
   gpu::SyncToken sync_token;
   if (context_provider_) {
     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 (fence) {
+      fence_id_ = gles2->CreateFenceCHROMIUM(fence->AsClientFence());
+      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_);
+    if (fence_id_) {
+      gles2->DestroyFenceCHROMIUM(fence_id_);
+      fence_id_ = 0;
+    }
     gles2->EndQueryEXT(query_type_);
     // Run callback when query result is available and ReleaseTexImage has been
     // handled.
     ReleaseWhenQueryResultIsAvailable(callback);
     // Create and return a sync token that can be used to ensure that the
     // CopyTextureCHROMIUM call is processed before issuing any commands
     // that will read from the target texture on a different context.
     uint64_t fence_sync = gles2->InsertFenceSyncCHROMIUM();
     gles2->OrderingBarrierCHROMIUM();
     gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
   }
   return sync_token;
 }
 
 void Buffer::Texture::DestroyResources() {
   if (context_provider_) {
     gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
     gles2->DeleteTextures(1, &texture_id_);
     if (query_id_)
       gles2->DeleteQueriesEXT(1, &query_id_);
     if (image_id_)
       gles2->DestroyImageCHROMIUM(image_id_);
+    if (fence_id_)
+      gles2->DestroyFenceCHROMIUM(fence_id_);
   }
 }
 
 void Buffer::Texture::ReleaseWhenQueryResultIsAvailable(
     const base::Closure& callback) {
   DCHECK(context_provider_);
   DCHECK(release_callback_.is_null());
   release_callback_ = callback;
   base::TimeDelta wait_for_release_delay =
       base::TimeDelta::FromMilliseconds(kWaitForReleaseDelayMs);
@@ skipping 67 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,
+    gfx::GpuFence* 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(fence));

[reveman, 2016/10/13 17:13:51]

nit: not need for std::move here anymore now that this is a raw pointer

 
     *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(
-      texture, base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
-                          base::Passed(&contents_texture_)));
+      std::move(fence), texture,

[reveman, 2016/10/13 17:13:51]

nit: same here

+      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),
                  base::Bind(&Buffer::ReleaseTexture, AsWeakPtr(),
                             base::Passed(&texture_))));
@@ skipping 49 matching lines @@
 }
 
 void Buffer::ReleaseContentsTexture(std::unique_ptr<Texture> texture) {
   TRACE_EVENT0("exo", "Buffer::ReleaseContentsTexture");
 
   contents_texture_ = std::move(texture);
   Release();
 }
 
 }  // namespace exo