Support ozone=1 compositor_unittests with OSMesa

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"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_make_current.h"
 
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
 }
 #endif
 
 #if defined (USE_OZONE)
@@ skipping 529 matching lines @@
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
 #if defined(ANDROID) || defined(USE_OZONE)
 
 // static
 bool GLSurface::InitializeOneOffInternal() {
+  if (GetGLImplementation() == kGLImplementationOSMesaGL) {
+    return true;
+  }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
 
   if (!GLSurfaceEGL::InitializeOneOff()) {
     LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
     return false;
   }
   return true;
 }
 
 // static
 scoped_refptr<GLSurface>
 GLSurface::CreateViewGLSurface(gfx::AcceleratedWidget window) {
+
+  if (GetGLImplementation() == kGLImplementationOSMesaGL) {
+    scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless(window));

[jonathan.backer, 2013/06/27 17:13:28]

Can we define this class in an anonymous namespace in this file? There's no need
for the rest of the world to know about it. This is what we do for
NativeViewGLSurfaceOSMesa.

[rjkroege, 2013/06/28 00:25:01]

Yes. But there is a difficulty around this. gl_surface_osmesa.cc needs a #define
from osmesa.h. But osmesa.h cannot be compiled in if it follows gl_bindings.h as
the EGL include files destructively alter the necessary pre-reqs. So: I cannot
put GLSurfaceOSMesaHeadless in gl_surface_egl.cc without either:

*  hard-coding a OSMesa constant in gl_surface_egl.cc
*  egregious include order violation

or I can leave it like this. Thoughts?

[jonathan.backer, 2013/06/28 13:13:47]

Thanks for the explanation. I have a slight preference for an include order
violation (it'll be in a .cc file) because I don't like exposing more than
necessary in a .h. We've had similar ordering violations with X includes and
we've just lumped it. If you choose to violate include order, just add a comment
why so no one bothers to try to clean it up.

That's just my dogma. Feel free to choose your own.

+    if (!surface->Initialize())
+      return NULL;
+    return surface;
+  }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window) {
     scoped_refptr<NativeViewGLSurfaceEGL> surface;
     VSyncProvider* sync_provider = NULL;
 #if defined(USE_OZONE)
     window = ui::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
         window);
     sync_provider =
         ui::SurfaceFactoryOzone::GetInstance()->GetVSyncProvider(window);
 #endif
     surface = new NativeViewGLSurfaceEGL(window);
     if(surface->Initialize(sync_provider))
       return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
     if (surface->Initialize())
       return surface;
   }
   return NULL;
 }
 
 // static
 scoped_refptr<GLSurface>
 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));
       if (!surface->Initialize())
         return NULL;
       return surface;
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx