Support swap damage rect using eglSwapBuffersWithDamageKHR

ui/gl/gl_surface_egl.cc

 // Copyright (c) 2012 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 "ui/gl/gl_surface_egl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 611 matching lines @@
 
   return g_display;
 }
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
       size_(1, 1),
       enable_fixed_size_angle_(false),
       surface_(NULL),
       supports_post_sub_buffer_(false),
+      supports_swap_buffer_with_damage_(false),
       flips_vertically_(false),
       swap_interval_(1) {
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 
 #if defined(OS_WIN)
   vsync_override_ = false;
   swap_generation_ = 0;
@@ skipping 72 matching lines @@
     return false;
   }
 
   if (g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
     EGLint surfaceVal;
     EGLBoolean retVal = eglQuerySurface(
         GetDisplay(), surface_, EGL_POST_SUB_BUFFER_SUPPORTED_NV, &surfaceVal);
     supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
   }
 
+  supports_swap_buffer_with_damage_ =
+      gfx::g_driver_egl.ext.b_EGL_KHR_swap_buffers_with_damage &&
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableSwapBuffersWithDamage);
+
   if (sync_provider)
     vsync_provider_.reset(sync_provider.release());
   else if (g_egl_sync_control_supported)
     vsync_provider_.reset(new EGLSyncControlVSyncProvider(surface_));
   return true;
 }
 
 bool NativeViewGLSurfaceEGL::InitializeNativeWindow() {
   return true;
 }
@@ skipping 120 matching lines @@
     return false;
   }
   return true;
 }
 
 EGLSurface NativeViewGLSurfaceEGL::GetHandle() {
   return surface_;
 }
 
 bool NativeViewGLSurfaceEGL::SupportsPostSubBuffer() {
-  return supports_post_sub_buffer_;
+  return supports_post_sub_buffer_ || supports_swap_buffer_with_damage_;
 }
 
 bool NativeViewGLSurfaceEGL::FlipsVertically() const {
   return flips_vertically_;
 }
 
 bool NativeViewGLSurfaceEGL::BuffersFlipped() const {
   return g_use_direct_composition;
 }
 
 gfx::SwapResult NativeViewGLSurfaceEGL::PostSubBuffer(int x,
                                                       int y,
                                                       int width,
                                                       int height) {
-  DCHECK(supports_post_sub_buffer_);
+  DCHECK(supports_post_sub_buffer_ || supports_swap_buffer_with_damage_);

[piman, 2016/09/02 18:25:47]

Well, the semantics of eglPostSubBufferNV and of eglSwapBuffersWithDamageKHR are
very different.

eglPostSubBufferNV only requires you to write the area that's referenced in the
rect. The rest of the backbuffer can be undefined. The driver may for example
implement it as a blit from back to front, but can't implement it as a trivial
flip.
eglSwapBuffersWithDamageKHR requires you to have the entire area correctly
defined, either because you know it already was (e.g. using buffer age, or with
EGL_SWAP_BEHAVIOR == EGL_BUFFER_PRESERVED) or by redrawing it. The driver may
implement it as a flip - but the damage is important for a compositor so that it
knows, in turn, what to re-composite.

So I don't think we should pretend to implement PostSubBuffer with
eglSwapBuffersWithDamageKHR - if we tell the compositor PostSubBuffer is
supported, it will not write the area outside of the damage region, and so we
may flip corrupted bits.

Instead we should introduce a new entrypoint that has the semantics of
SwapBuffersWithDamage - or possibly just augment SwapBuffers to have an optional
damage rect, and ensure the compositor does write the whole buffer, but still
tracks the damage rect and passes it along.

[halliwell, 2016/09/07 03:17:07]

And yes, I understood the difference between this and PostSubBufferNV ... I was
really just being lazy in reusing the plumbing, and patching it up by computing
the damage rect differently :)

   UpdateSwapInterval();
   if (!CommitAndClearPendingOverlays()) {
     DVLOG(1) << "Failed to commit pending overlay planes.";
     return gfx::SwapResult::SWAP_FAILED;
   }
   if (flips_vertically_) {
     // With EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE the contents are rendered
     // inverted, but the PostSubBuffer rectangle is still measured from the
     // bottom left.
     y = GetSize().height() - y - height;
   }
-  if (!eglPostSubBufferNV(GetDisplay(), surface_, x, y, width, height)) {
-    DVLOG(1) << "eglPostSubBufferNV failed with error "
-             << GetLastEGLErrorString();
-    return gfx::SwapResult::SWAP_FAILED;
+
+  if (supports_post_sub_buffer_) {
+    if (!eglPostSubBufferNV(GetDisplay(), surface_, x, y, width, height)) {
+      DVLOG(1) << "eglPostSubBufferNV failed with error "
+               << GetLastEGLErrorString();
+      return gfx::SwapResult::SWAP_FAILED;
+    }
+  } else {
+    EGLint damage_rect[4] = {x, y, width, height};
+    if (!eglSwapBuffersWithDamageKHR(GetDisplay(), surface_, damage_rect, 1)) {
+      DVLOG(1) << "eglSwapBuffersWithDamageKHR failed with error "
+               << GetLastEGLErrorString();
+      return gfx::SwapResult::SWAP_FAILED;
+    }
   }
   return gfx::SwapResult::SWAP_ACK;
 }
 
 bool NativeViewGLSurfaceEGL::SupportsCommitOverlayPlanes() {
 #if defined(OS_ANDROID)
   return true;
 #else
   return false;
 #endif
@@ skipping 241 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl