Allocate buffer IDs for the ozone wayland backend uniquely.

This CL lets WaylandBufferManagerGpu allocate buffer ids for
GbmPixmapWayland and WaylandCanvasSurface to make sure they are unique.

Bug: 1039806
Bug: 1039429
Test: no collision between buffer ids
Change-Id: I9c66c1fe234fac45e20dd8792353c93fa4a1cb86
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2006907Reviewed-by: Maksim Sisov <msisov@igalia.com>
Reviewed-by: Thomas Anderson <thomasanderson@chromium.org>
Commit-Queue: Eliot Courtney <edcourtney@chromium.org>
Cr-Commit-Position: refs/heads/master@{#735317}

ui/ozone/platform/wayland/gpu/gbm_pixmap_wayland.cc

@@ -30,11 +30,12 @@
 namespace ui {
 
 GbmPixmapWayland::GbmPixmapWayland(WaylandBufferManagerGpu* buffer_manager)
-    : buffer_manager_(buffer_manager) {}
+    : buffer_manager_(buffer_manager),
+      buffer_id_(buffer_manager->AllocateBufferID()) {}
 
 GbmPixmapWayland::~GbmPixmapWayland() {
   if (gbm_bo_)
-    buffer_manager_->DestroyBuffer(widget_, GetUniqueId());
+    buffer_manager_->DestroyBuffer(widget_, buffer_id_);
 }
 
 bool GbmPixmapWayland::InitializeBuffer(gfx::Size size,
@@ -129,7 +130,8 @@ bool GbmPixmapWayland::ScheduleOverlayPlane(
 
   surfaceless->QueueOverlayPlane(
       OverlayPlane(this, std::move(gpu_fence), plane_z_order, plane_transform,
-                   display_bounds, crop_rect, enable_blend));
+                   display_bounds, crop_rect, enable_blend),
+      buffer_id_);
   return true;
 }
 
@@ -180,7 +182,7 @@ void GbmPixmapWayland::CreateDmabufBasedBuffer() {
   // Asks Wayland to create a wl_buffer based on the |file| fd.
   buffer_manager_->CreateDmabufBasedBuffer(
       std::move(fd), GetBufferSize(), strides, offsets, modifiers,
-      gbm_bo_->GetFormat(), plane_count, GetUniqueId());
+      gbm_bo_->GetFormat(), plane_count, buffer_id_);
 }
 
 }  // namespace ui

ui/ozone/platform/wayland/gpu/gbm_pixmap_wayland.h

@@ -67,6 +67,9 @@ class GbmPixmapWayland : public gfx::NativePixmap {
   // Represents widget this pixmap backs.
   gfx::AcceleratedWidget widget_ = gfx::kNullAcceleratedWidget;
 
+  // A unique ID to identify the buffer for this pixmap.
+  const uint32_t buffer_id_;
+
   DISALLOW_COPY_AND_ASSIGN(GbmPixmapWayland);
 };
 

ui/ozone/platform/wayland/gpu/gbm_surfaceless_wayland.cc

@@ -38,8 +38,9 @@ GbmSurfacelessWayland::GbmSurfacelessWayland(
   unsubmitted_frames_.push_back(std::make_unique<PendingFrame>());
 }
 
-void GbmSurfacelessWayland::QueueOverlayPlane(OverlayPlane plane) {
-  planes_.push_back(std::move(plane));
+void GbmSurfacelessWayland::QueueOverlayPlane(OverlayPlane plane,
+                                              uint32_t buffer_id) {
+  planes_.push_back({std::move(plane), buffer_id});
 }
 
 bool GbmSurfacelessWayland::ScheduleOverlayPlane(
@@ -209,7 +210,7 @@ void GbmSurfacelessWayland::SubmitFrame() {
       return;
     }
 
-    submitted_frame_->buffer_id = planes_.back().pixmap->GetUniqueId();
+    submitted_frame_->buffer_id = planes_.back().buffer_id;
     buffer_manager_->CommitBuffer(widget_, submitted_frame_->buffer_id,
                                   submitted_frame_->damage_region_);
 

ui/ozone/platform/wayland/gpu/gbm_surfaceless_wayland.h

@@ -29,7 +29,7 @@ class GbmSurfacelessWayland : public gl::SurfacelessEGL,
   GbmSurfacelessWayland(WaylandBufferManagerGpu* buffer_manager,
                         gfx::AcceleratedWidget widget);
 
-  void QueueOverlayPlane(OverlayPlane plane);
+  void QueueOverlayPlane(OverlayPlane plane, uint32_t buffer_id);
 
   // gl::GLSurface:
   bool ScheduleOverlayPlane(int z_order,
@@ -88,13 +88,18 @@ class GbmSurfacelessWayland : public gl::SurfacelessEGL,
     PresentationCallback presentation_callback;
   };
 
+  struct PlaneData {
+    OverlayPlane plane;
+    const uint32_t buffer_id;
+  };
+
   void SubmitFrame();
 
   EGLSyncKHR InsertFence(bool implicit);
   void FenceRetired(PendingFrame* frame);
 
   WaylandBufferManagerGpu* const buffer_manager_;
-  std::vector<OverlayPlane> planes_;
+  std::vector<PlaneData> planes_;
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   gfx::AcceleratedWidget widget_;

ui/ozone/platform/wayland/gpu/wayland_buffer_manager_gpu.cc

@@ -158,6 +158,10 @@ WaylandBufferManagerGpu::GetModifiersForBufferFormat(
   return dummy;
 }
 
+uint32_t WaylandBufferManagerGpu::AllocateBufferID() {
+  return ++next_buffer_id_;
+}
+
 void WaylandBufferManagerGpu::CreateDmabufBasedBufferInternal(
     base::ScopedFD dmabuf_fd,
     gfx::Size size,

ui/ozone/platform/wayland/gpu/wayland_buffer_manager_gpu.h

@@ -123,6 +123,9 @@ class WaylandBufferManagerGpu : public ozone::mojom::WaylandBufferManagerGpu {
   const std::vector<uint64_t>& GetModifiersForBufferFormat(
       gfx::BufferFormat buffer_format) const;
 
+  // Allocates a unique buffer ID.
+  uint32_t AllocateBufferID();
+
  private:
   void CreateDmabufBasedBufferInternal(base::ScopedFD dmabuf_fd,
                                        gfx::Size size,
@@ -193,6 +196,9 @@ class WaylandBufferManagerGpu : public ozone::mojom::WaylandBufferManagerGpu {
   // Protects access to |widget_to_surface_map_|.
   base::Lock lock_;
 
+  // Keeps track of the next unique buffer ID.
+  uint32_t next_buffer_id_ = 0;
+
   DISALLOW_COPY_AND_ASSIGN(WaylandBufferManagerGpu);
 };
 

ui/ozone/platform/wayland/gpu/wayland_canvas_surface.cc

@@ -35,10 +35,9 @@ size_t CalculateStride(int width) {
 
 class WaylandCanvasSurface::SharedMemoryBuffer {
  public:
-  SharedMemoryBuffer(uint32_t buffer_id,
-                     gfx::AcceleratedWidget widget,
+  SharedMemoryBuffer(gfx::AcceleratedWidget widget,
                      WaylandBufferManagerGpu* buffer_manager)
-      : buffer_id_(buffer_id),
+      : buffer_id_(buffer_manager->AllocateBufferID()),
         widget_(widget),
         buffer_manager_(buffer_manager) {
     DCHECK(buffer_manager_);
@@ -294,8 +293,8 @@ std::unique_ptr<WaylandCanvasSurface::SharedMemoryBuffer>
 WaylandCanvasSurface::CreateSharedMemoryBuffer() {
   DCHECK(!size_.IsEmpty());
 
-  auto canvas_buffer = std::make_unique<SharedMemoryBuffer>(
-      ++buffer_id_, widget_, buffer_manager_);
+  auto canvas_buffer =
+      std::make_unique<SharedMemoryBuffer>(widget_, buffer_manager_);
   return canvas_buffer->Initialize(size_) ? std::move(canvas_buffer) : nullptr;
 }
 

ui/ozone/platform/wayland/gpu/wayland_canvas_surface.h

@@ -73,11 +73,6 @@ class WaylandCanvasSurface : public SurfaceOzoneCanvas,
   // Previously used buffer. Set on OnSubmission().
   SharedMemoryBuffer* previous_buffer_ = nullptr;
 
-  // The id of the current existing buffer. Even though, there can only be one
-  // buffer (SkSurface) at a time, the buffer manager on the browser process
-  // side requires buffer id to be passed.
-  uint32_t buffer_id_ = 0;
-
   DISALLOW_COPY_AND_ASSIGN(WaylandCanvasSurface);
 };