Add support for Khr_surfaceless_context.

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.
 
 // This include must be here so that the includes provided transitively
 // by gl_surface_egl.h don't make it impossible to compile this code.
 #include "third_party/mesa/src/include/GL/osmesa.h"
 
 #include "ui/gl/gl_surface_egl.h"
 
@@ skipping 36 matching lines @@
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 
 const char* g_egl_extensions = NULL;
 bool g_egl_create_context_robustness_supported = false;
 bool g_egl_sync_control_supported = false;
+bool g_egl_surfaceless_context = false;

[piman, 2013/10/31 20:07:54]

nit: g_egl_surfaceless_context_supported for consistency

[kalyank, 2013/10/31 22:15:27]

fixed.

 
 class EGLSyncControlVSyncProvider
     : public gfx::SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
       : SyncControlVSyncProvider(),
         surface_(surface) {
   }
 
   virtual ~EGLSyncControlVSyncProvider() { }
@@ skipping 110 matching lines @@
                << GetLastEGLErrorString();
     return false;
   }
 
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   g_egl_create_context_robustness_supported =
       HasEGLExtension("EGL_EXT_create_context_robustness");
   g_egl_sync_control_supported =
       HasEGLExtension("EGL_CHROMIUM_sync_control");
 
+  // Check if SurfacelessEGL is supported.
+  g_egl_surfaceless_context = HasEGLExtension("EGL_KHR_surfaceless_context");
+  if (g_egl_surfaceless_context) {
+    // EGL_KHR_surfaceless_context is supported but ensure
+    // GL_OES_surfaceless_context is also supported. We need a current context
+    // to query for supported GL extensions.
+    scoped_refptr<GLSurface> surface = new SurfacelessEGL(Size(1, 1));
+    scoped_refptr<GLContext> context = GLContext::CreateGLContext(
+      NULL, surface.get(), PreferIntegratedGpu);
+    if (!context->MakeCurrent(surface.get()))
+      g_egl_surfaceless_context = false;
+
+    // Ensure context supports GL_OES_surfaceless_context.
+    if (g_egl_surfaceless_context) {
+      g_egl_surfaceless_context = context->HasExtension(
+          "GL_OES_surfaceless_context");
+      context->ReleaseCurrent(surface.get());
+    }
+  }
+
   initialized = true;
 
   return true;
 }
 
 EGLDisplay GLSurfaceEGL::GetDisplay() {
   return g_display;
 }
 
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
@@ skipping 389 matching lines @@
   }
 
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
+SurfacelessEGL::SurfacelessEGL(const gfx::Size& size)
+    : size_(size) {
+}
+
+bool SurfacelessEGL::Initialize() {
+  return true;
+}
+
+void SurfacelessEGL::Destroy() {
+}
+
+EGLConfig SurfacelessEGL::GetConfig() {
+  return g_config;
+}
+
+bool SurfacelessEGL::IsOffscreen() {
+  return true;
+}
+
+bool SurfacelessEGL::SwapBuffers() {
+  NOTREACHED() << "Attempted to call SwapBuffers with SurfacelessEGL.";

[piman, 2013/10/31 20:07:54]

note: technically it can be reached if the (untrusted) client call SwapBuffers
on the offscreen context. Maybe LOG(ERROR) instead.

[kalyank, 2013/10/31 22:15:27]

fixed.

+  return false;
+}
+
+gfx::Size SurfacelessEGL::GetSize() {
+  return size_;
+}
+
+bool SurfacelessEGL::Resize(const gfx::Size& size) {
+  size_ = size;
+  return true;
+}
+
+EGLSurface SurfacelessEGL::GetHandle() {
+  return EGL_NO_SURFACE;
+}
+
+void* SurfacelessEGL::GetShareHandle() {
+  return NULL;
+}
+
+SurfacelessEGL::~SurfacelessEGL() {
+}
+
 #if defined(ANDROID) || defined(USE_OZONE)
 
 // A thin subclass of |GLSurfaceOSMesa| that can be used in place
 // of a native hardware-provided surface when a native surface
 // provider is not available.
 class GLSurfaceOSMesaHeadless : public GLSurfaceOSMesa {
  public:
   explicit GLSurfaceOSMesaHeadless(gfx::AcceleratedWidget window);
 
   virtual bool IsOffscreen() OVERRIDE;
@@ skipping 68 matching lines @@
 GLSurface::CreateOffscreenGLSurface(const gfx::Size& size) {
   switch (GetGLImplementation()) {
     case kGLImplementationOSMesaGL: {
       scoped_refptr<GLSurface> surface(new GLSurfaceOSMesa(1, size));
       if (!surface->Initialize())
         return NULL;
 
       return surface;
     }
     case kGLImplementationEGLGLES2: {
-      scoped_refptr<PbufferGLSurfaceEGL> surface(
-          new PbufferGLSurfaceEGL(size));
+      scoped_refptr<GLSurface> surface;
+      if (g_egl_surfaceless_context)
+        surface = new SurfacelessEGL(size);

[piman, 2013/10/31 20:07:54]

So, what if the client really meant to have an offscreen backbuffer? Could we
make this choice based on, say, size being (0x0), and fix the callers? We pass
1x1 everywhere for historical reasons, but we should clean that up...

[kalyank, 2013/10/31 22:15:27]

I for now added the checks with 1,1 size. If no one has started working on it, I
can fix the callers and change the size to 0x0 in a separate CL?

+      else
+        surface = new PbufferGLSurfaceEGL(size);
+
       if (!surface->Initialize())
         return NULL;
       return surface;
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx