Plumb through EGL_NV_post_sub_buffer and GLX_MESA_copy_sub_buffer.

ui/gfx/gl/gl_surface_egl.cc

 // Copyright (c) 2011 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/gfx/gl/gl_surface_egl.h"
 
 #include "build/build_config.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/angle/include/EGL/egl.h"
@@ skipping 155 matching lines @@
   return g_software_display;
 }
 
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
   return g_native_display;
 }
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(bool software,
                                                gfx::PluginWindowHandle window)
     : window_(window),
-      surface_(NULL)
+      surface_(NULL),
+      supports_post_sub_buffer_(false)
 {
   software_ = software;
 }
 
 NativeViewGLSurfaceEGL::~NativeViewGLSurfaceEGL() {
   Destroy();
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
   DCHECK(!surface_);
 
   if (!GetDisplay()) {
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
   }
 
+  static const EGLint egl_window_attributes_sub_buffer[] = {
+    EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_TRUE,
+    EGL_NONE
+  };
+
   // Create a surface for the native window.
   surface_ = eglCreateWindowSurface(GetDisplay(),
                                     GetConfig(),
                                     window_,
-                                    NULL);
+                                    gfx::g_EGL_NV_post_sub_buffer ?
+                                      egl_window_attributes_sub_buffer :
+                                      NULL);
 
   if (!surface_) {
     LOG(ERROR) << "eglCreateWindowSurface failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
 
+  EGLint surfaceVal;
+  EGLBoolean retVal = eglQuerySurface(GetDisplay(),

[apatrick_chromium, 2011/11/10 19:33:16]

Is it really the case that if you ask for a surface with EGL_NV_post_sub_buffer,
it will succeed but then report that it is not supported via QuerySurface? It
would be nice if the feature info code could just assume that if the
EGL_NV_post_sub_buffer extension is reported as available then  it can report it
as available to the client.

[jonathan.backer, 2011/11/10 21:00:25]

I think so. I was inspired by some ChromeOS WM code.

From the bottom of
http://www.khronos.org/registry/egl/extensions/NV/EGL_NV_post_sub_buffer.txt in
the revision history:

"Allowed EGL_POST_SUB_BUFFER_SUPPORTED_NV to be used as a hint when creating
window surfaces."

FWIW, the Intel GLES stack succeeds with the code as is (still get a window
surface), but correctly says that it doesn't support the extension.

+                                      surface_,
+                                      EGL_POST_SUB_BUFFER_SUPPORTED_NV,
+                                      &surfaceVal);
+  supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
+
   return true;
 }
 
 void NativeViewGLSurfaceEGL::Destroy() {
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
@@ skipping 24 matching lines @@
     return gfx::Size();
   }
 
   return gfx::Size(width, height);
 }
 
 EGLSurface NativeViewGLSurfaceEGL::GetHandle() {
   return surface_;
 }
 
+bool NativeViewGLSurfaceEGL::SupportsPostSubBuffer() {
+  return supports_post_sub_buffer_;
+}
+
+bool NativeViewGLSurfaceEGL::PostSubBuffer(
+    int x, int y, int width, int height) {
+  DCHECK(supports_post_sub_buffer_);
+  return eglPostSubBufferNV(GetDisplay(), surface_, x, y, width, height);
+}
+
 PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(bool software, const gfx::Size& size)
     : size_(size),
       surface_(NULL) {
   software_ = software;
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
@@ skipping 70 matching lines @@
                                    GetHandle(),
                                    EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE,
                                    &handle)) {
     return NULL;
   }
 
   return handle;
 }
 
 }  // namespace gfx