ozone: demo: support multiple overlays

Uses multiple overlays to display rectangles.

BUG=none
TEST=ozone_demo --enable-overlay=2

Change-Id: Ic6cb683dbc043744597261fe15c711e09390ef46
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1922705
Commit-Queue: Fritz Koenig <frkoenig@chromium.org>
Auto-Submit: Fritz Koenig <frkoenig@chromium.org>
Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Reviewed-by: Michael Spang <spang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#721091}

ui/ozone/demo/surfaceless_gl_renderer.cc

@@ -12,6 +12,7 @@
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ -136,8 +137,10 @@ SurfacelessGlRenderer::~SurfacelessGlRenderer() {
   for (size_t i = 0; i < base::size(buffers_); ++i)
     buffers_[i].reset();
 
-  for (size_t i = 0; i < base::size(overlay_buffers_); ++i)
-    overlay_buffers_[i].reset();
+  for (size_t i = 0; i < kMaxLayers; ++i) {
+    for (size_t j = 0; j < base::size(overlay_buffers_[i]); ++j)
+      overlay_buffers_[i][j].reset();
+  }
 }
 
 bool SurfacelessGlRenderer::Initialize() {
@@ -168,20 +171,29 @@ bool SurfacelessGlRenderer::Initialize() {
   }
 
   if (command_line->HasSwitch("enable-overlay")) {
-    gfx::Size overlay_size = gfx::Size(size_.width() / 8, size_.height() / 8);
-    for (size_t i = 0; i < base::size(overlay_buffers_); ++i) {
-      overlay_buffers_[i] = std::make_unique<BufferWrapper>();
-      overlay_buffers_[i]->Initialize(gfx::kNullAcceleratedWidget,
-                                      overlay_size);
-
-      glViewport(0, 0, overlay_size.width(), overlay_size.height());
-      glClearColor(i, 1.0, 0.0, 1.0);
-      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-      // Ensure that the rendering has been committed to the buffer and thus
-      // that the buffer is ready for display without additional
-      // synchronization. This allows us to avoid using fences for display
-      // synchronization of the non-overlay buffers in RenderFrame.
-      glFinish();
+    int requested_overlay_cnt;
+    base::StringToInt(
+        command_line->GetSwitchValueASCII("enable-overlay").c_str(),
+        &requested_overlay_cnt);
+    overlay_cnt_ = std::max(1, std::min(kMaxLayers, requested_overlay_cnt));
+
+    const gfx::Size overlay_size =
+        gfx::Size(size_.width() / 8, size_.height() / 8);
+    for (size_t i = 0; i < overlay_cnt_; ++i) {
+      for (size_t j = 0; j < base::size(overlay_buffers_[i]); ++j) {
+        overlay_buffers_[i][j] = std::make_unique<BufferWrapper>();
+        overlay_buffers_[i][j]->Initialize(gfx::kNullAcceleratedWidget,
+                                           overlay_size);
+
+        glViewport(0, 0, overlay_size.width(), overlay_size.height());
+        glClearColor(j, 1.0, 0.0, 1.0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        // Ensure that the rendering has been committed to the buffer and thus
+        // that the buffer is ready for display without additional
+        // synchronization. This allows us to avoid using fences for display
+        // synchronization of the non-overlay buffers in RenderFrame.
+        glFinish();
+      }
     }
   }
 
@@ -199,7 +211,7 @@ void SurfacelessGlRenderer::RenderFrame() {
 
   float fraction = NextFraction();
 
-  gfx::Rect overlay_rect;
+  gfx::Rect overlay_rect[kMaxLayers];
   const gfx::RectF unity_rect = gfx::RectF(0, 0, 1, 1);
 
   OverlayCandidatesOzone::OverlaySurfaceCandidateList overlay_list;
@@ -209,17 +221,20 @@ void SurfacelessGlRenderer::RenderFrame() {
     // We know at least the primary plane can be scanned out.
     overlay_list.back().overlay_handled = true;
   }
-  if (overlay_buffers_[0]) {
-    overlay_rect = gfx::Rect(overlay_buffers_[0]->size());
+
+  for (size_t i = 0; i < overlay_cnt_; ++i) {
+    overlay_rect[i] = gfx::Rect(overlay_buffers_[i][0]->size());
 
     float steps_num = 5.0f;
     float stepped_fraction =
         std::floor((fraction + 0.5f / steps_num) * steps_num) / steps_num;
     gfx::Vector2d offset(
-        stepped_fraction * (size_.width() - overlay_rect.width()),
-        (size_.height() - overlay_rect.height()) / 2);
-    overlay_rect += offset;
-    overlay_list.push_back(MakeOverlayCandidate(1, overlay_rect, unity_rect));
+        stepped_fraction * (size_.width() - overlay_rect[i].width()),
+        ((size_.height() / (overlay_cnt_ + 1)) * (i + 1) -
+         overlay_rect[i].height() / 2));
+    overlay_rect[i] += offset;
+    overlay_list.push_back(
+        MakeOverlayCandidate(1, overlay_rect[i], unity_rect));
   }
 
   // The actual validation for a specific overlay configuration is done
@@ -256,11 +271,13 @@ void SurfacelessGlRenderer::RenderFrame() {
         gl_fence ? gl_fence->GetGpuFence() : nullptr);
   }
 
-  if (overlay_buffers_[0] && overlay_list.back().overlay_handled) {
-    gl_surface_->ScheduleOverlayPlane(1, gfx::OVERLAY_TRANSFORM_NONE,
-                                      overlay_buffers_[back_buffer_]->image(),
-                                      overlay_rect, unity_rect, false,
-                                      /* gpu_fence */ nullptr);
+  for (size_t i = 0; i < overlay_cnt_; ++i) {
+    if (overlay_list.back().overlay_handled) {
+      gl_surface_->ScheduleOverlayPlane(
+          1, gfx::OVERLAY_TRANSFORM_NONE,
+          overlay_buffers_[i][back_buffer_]->image(), overlay_rect[i],
+          unity_rect, false, /* gpu_fence */ nullptr);
+    }
   }
 
   back_buffer_ ^= 1;

ui/ozone/demo/surfaceless_gl_renderer.h

@@ -19,6 +19,8 @@ namespace ui {
 class OverlayCandidatesOzone;
 class PlatformWindowSurface;
 
+static const int kMaxLayers = 8;
+
 class SurfacelessGlRenderer : public RendererBase {
  public:
   SurfacelessGlRenderer(gfx::AcceleratedWidget widget,
@@ -59,7 +61,8 @@ class SurfacelessGlRenderer : public RendererBase {
 
   std::unique_ptr<BufferWrapper> buffers_[2];
 
-  std::unique_ptr<BufferWrapper> overlay_buffers_[2];
+  std::unique_ptr<BufferWrapper> overlay_buffers_[kMaxLayers][2];
+  size_t overlay_cnt_ = 0;
   bool disable_primary_plane_ = false;
   gfx::Rect primary_plane_rect_;
   bool use_gpu_fences_ = false;