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.
 
+// 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"
 
 #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 527 matching lines @@
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
 #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;
+  virtual bool SwapBuffers() OVERRIDE;
+
+ protected:
+  virtual ~GLSurfaceOSMesaHeadless();
+
+ private:
+
+  DISALLOW_COPY_AND_ASSIGN(GLSurfaceOSMesaHeadless);
+};
+
+bool GLSurfaceOSMesaHeadless::IsOffscreen() { return false; }
+
+bool GLSurfaceOSMesaHeadless::SwapBuffers() { return true; }
+
+GLSurfaceOSMesaHeadless::GLSurfaceOSMesaHeadless(gfx::AcceleratedWidget window)
+    : GLSurfaceOSMesa(OSMESA_BGRA, gfx::Size(1, 1)) {
+  DCHECK(window);
+}
+
+GLSurfaceOSMesaHeadless::~GLSurfaceOSMesaHeadless() { Destroy(); }
+
 // 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));
+    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