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>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer_owner_delegate.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/gpu_fence.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace cc {
 class SurfaceFactory;
 }
@@ skipping 66 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 (as a raw file descriptor) for the next surface

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

nit: update comment as this is not a raw file descriptor but instead the
abstract GpuFence class.

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

Done.

+  // commit. A buffer must be attached in the same transaction as applying a

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

What happens if a client doesn't respect this? We can't trust the client to do
the right thing so we need to make sure we do something reasonable if misused.

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

Probably the same which happens if 'A buffer can only be attached to one surface
at a time' is violated? We can kill the client (harsh, but gets the point across
quickly), or use the first one (discarding others), or the last. I have no real
preference for which would be best.

+  // fence.
+  void FenceAcquire(std::unique_ptr<gfx::GpuFence> fence);

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

nit: s/FenceAcquire/SetAcquireFence/. We try to match the wayland interfaces in
terms of naming as much as possible in exo code.

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

Done.

+
   // 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 204 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_;
 
+  std::unique_ptr<gfx::GpuFence> acquire_fence_;

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

nit: can you move acquire_fence_ just below current_buffer_ on line 382 and keep
pending_acquire_fence_ here as now.
nit: a short comment in both cases similar to other pending/active state would
be nice for consistency.

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

Done.

+  std::unique_ptr<gfx::GpuFence> pending_acquire_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 55 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_