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_supported = false;
 
 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_supported =
+      HasEGLExtension("EGL_KHR_surfaceless_context");
+  if (g_egl_surfaceless_context_supported) {
+    // 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_supported = false;
+
+    // Ensure context supports GL_OES_surfaceless_context.
+    if (g_egl_surfaceless_context_supported) {
+      g_egl_surfaceless_context_supported = 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() {
+  LOG(ERROR) << "Attempted to call SwapBuffers with SurfacelessEGL.";
+  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_supported &&
+         (size.width() == 0 && size.height() == 0)) {
+        surface = new SurfacelessEGL(size);
+      } else
+        surface = new PbufferGLSurfaceEGL(size);
+
       if (!surface->Initialize())
         return NULL;
       return surface;
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx