exo: Add zcr_linux_explicit_synchronization_v1

components/exo/surface.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/surface.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/widget/widget.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(exo::Surface*);
 
 namespace exo {
 namespace {
@@ skipping 205 matching lines @@
 }
 
 void Surface::Attach(Buffer* buffer) {
   TRACE_EVENT1("exo", "Surface::Attach", "buffer",
                buffer ? buffer->GetSize().ToString() : "null");
 
   has_pending_contents_ = true;
   pending_buffer_.Reset(buffer ? buffer->AsWeakPtr() : base::WeakPtr<Buffer>());
 }
 
+void Surface::SetAcquireFence(std::unique_ptr<gfx::GpuFence> fence) {
+  TRACE_EVENT1("exo", "Surface::FenceAcquire", "fence", !!fence);
+
+  pending_fence_ = std::move(fence);
+}
+
 void Surface::Damage(const gfx::Rect& damage) {
   TRACE_EVENT1("exo", "Surface::Damage", "damage", damage.ToString());
 
   pending_damage_.op(gfx::RectToSkIRect(damage), SkRegion::kUnion_Op);
 }
 
 void Surface::RequestFrameCallback(const FrameCallback& callback) {
   TRACE_EVENT0("exo", "Surface::RequestFrameCallback");
 
   pending_frame_callbacks_.push_back(callback);
@@ skipping 186 matching lines @@
   has_pending_layer_changes_ = false;
 
   state_ = pending_state_;
   pending_state_.only_visible_on_secure_output = false;
 
   // We update contents if Attach() has been called since last commit.
   if (has_pending_contents_) {
     has_pending_contents_ = false;
 
     current_buffer_ = std::move(pending_buffer_);
+    fence_ = std::move(pending_fence_);
 
     UpdateResource(true);
   }
 
   cc::LocalFrameId old_local_frame_id = local_frame_id_;
   if (needs_commit_to_new_surface_ || local_frame_id_.is_null()) {
     needs_commit_to_new_surface_ = false;
     local_frame_id_ = factory_owner_->id_allocator_->GenerateId();
     factory_owner_->surface_factory_->Create(local_frame_id_);
   }
@@ skipping 229 matching lines @@
       layer_size, contents_surface_to_layer_scale, layer_size);
 }
 
 void Surface::UpdateResource(bool client_usage) {
   std::unique_ptr<cc::SingleReleaseCallback> texture_mailbox_release_callback;
 
   cc::TextureMailbox texture_mailbox;
   if (current_buffer_.buffer()) {
     texture_mailbox_release_callback =
         current_buffer_.buffer()->ProduceTextureMailbox(
-            &texture_mailbox, state_.only_visible_on_secure_output,
-            client_usage);
+            &texture_mailbox, fence_.get(),
+            state_.only_visible_on_secure_output, client_usage);
   }
 
   if (texture_mailbox_release_callback) {
     cc::TransferableResource resource;
     resource.id = next_resource_id_++;
     resource.format = cc::RGBA_8888;
     resource.filter =
         texture_mailbox.nearest_neighbor() ? GL_NEAREST : GL_LINEAR;
     resource.size = texture_mailbox.size_in_pixels();
     resource.mailbox_holder = gpu::MailboxHolder(texture_mailbox.mailbox(),
@@ skipping 119 matching lines @@
 
 int64_t Surface::GetPropertyInternal(const void* key,
                                      int64_t default_value) const {
   std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
   if (iter == prop_map_.end())
     return default_value;
   return iter->second.value;
 }
 
 }  // namespace exo