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.

[kalyank, 2013/10/31 23:49:12]

On a second thought another possible solution to avoid regression on other
platforms :
Guard extension checks for ozone. So, SurfacelessEGL support is only enabled for
ozone with this CL.

Than we can create another CL which would make appropriate changes to enable
this on other supported platforms?

+  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() == 1 && size.height() == 1)) {

[piman, 2013/10/31 22:51:24]

How about checking with 0,0 so that we don't regress?

[kalyank, 2013/10/31 23:18:07]

Ya, I am k with that. I see that GPUChannerManager creates default offscreen
surface with a size of 1,1. The offscreen surface is used by texture
imagetransportsurface, commnadbuffer stub etc. so, is this something which needs
to be changed ? In other places we construct PBufferSurface directly i.e. in
imagetransportsurfacewin etc

I was thinking it's bit safe as it's used only with ozone egl backend but
realized the code is used by Android too.

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