exo: Implement zcr_linux_explicit_synchronization_v1

components/exo/surface.h

 // 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.
 
 #ifndef COMPONENTS_EXO_SURFACE_H_
 #define COMPONENTS_EXO_SURFACE_H_
 
 #include <list>
 #include <memory>
 #include <set>
@@ skipping 16 matching lines @@
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace cc {
 class SurfaceFactory;
 }
 
 namespace gfx {
+class GpuFence;
 class Path;
 }
 
 namespace exo {
 class Buffer;
 class Pointer;
 class SurfaceDelegate;
 class SurfaceObserver;
 class Surface;
 
@@ skipping 53 matching lines @@
 
   aura::Window* window() { return window_.get(); }
 
   const cc::LocalFrameId& local_frame_id() const { return local_frame_id_; }
   cc::SurfaceId GetSurfaceId() const;
 
   // Set a buffer as the content of this surface. A buffer can only be attached
   // to one surface at a time.
   void Attach(Buffer* buffer);
 
+  // Provide an acquire-fence for the next surface commit. A buffer must be
+  // attached in the same transaction as applying a fence.
+  void SetAcquireFence(std::unique_ptr<gfx::GpuFence> fence);
+
   // Describe the regions where the pending buffer is different from the
   // current surface contents, and where the surface therefore needs to be
   // repainted.
   void Damage(const gfx::Rect& rect);
 
   // Request notification when the next frame is displayed. Useful for
   // throttling redrawing operations, and driving animations.
   using FrameCallback = base::Callback<void(base::TimeTicks frame_time)>;
   void RequestFrameCallback(const FrameCallback& callback);
 
@@ skipping 201 matching lines @@
   // This is the size of the last committed contents.
   gfx::Size content_size_;
 
   // This is true when Attach() has been called and new contents should take
   // effect next time Commit() is called.
   bool has_pending_contents_ = false;
 
   // The buffer that will become the content of surface when Commit() is called.
   BufferAttachment pending_buffer_;
 
+  // The fence which will be used to wait before sourcing from
+  // |pending_buffer_|, on next Commit().
+  std::unique_ptr<gfx::GpuFence> pending_fence_;
+
   cc::SurfaceManager* surface_manager_;
 
   scoped_refptr<SurfaceFactoryOwner> factory_owner_;
 
   // The Surface Id currently attached to the window.
   cc::LocalFrameId local_frame_id_;
 
   // The next resource id the buffer will be attached to.
   int next_resource_id_ = 1;
 
@@ skipping 19 matching lines @@
   // The stack of sub-surfaces to take effect when Commit() is called.
   // Bottom-most sub-surface at the front of the list and top-most sub-surface
   // at the back.
   using SubSurfaceEntry = std::pair<Surface*, gfx::Point>;
   using SubSurfaceEntryList = std::list<SubSurfaceEntry>;
   SubSurfaceEntryList pending_sub_surfaces_;
 
   // The buffer that is currently set as content of surface.
   BufferAttachment current_buffer_;
 
+  // The fence which will be used to wait before sourcing from
+  // |current_buffer_|.
+  std::unique_ptr<gfx::GpuFence> fence_;
+
   // The last resource that was sent to a surface.
   cc::TransferableResource current_resource_;
 
   // This is true if a call to Commit() as been made but
   // CommitSurfaceHierarchy() has not yet been called.
   bool needs_commit_surface_hierarchy_ = false;
 
   // This is set when the compositing starts and passed to active frame
   // callbacks when compositing successfully ends.
   base::TimeTicks last_compositing_start_time_;
@@ skipping 16 matching lines @@
 
   // Surface observer list. Surface does not own the observers.
   base::ObserverList<SurfaceObserver, true> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(Surface);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_SURFACE_H_