GBM Ozone implementation

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 345 matching lines @@
 
   static const EGLint egl_window_attributes_sub_buffer[] = {
     EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_TRUE,
     EGL_NONE
   };
 
   // Create a surface for the native window.
   surface_ = eglCreateWindowSurface(
       GetDisplay(),
       GetConfig(),
-      window_,
+      reinterpret_cast<EGLNativeWindowType>(window_),
       gfx::g_driver_egl.ext.b_EGL_NV_post_sub_buffer ?
           egl_window_attributes_sub_buffer :
           NULL);
 
   if (!surface_) {
     LOG(ERROR) << "eglCreateWindowSurface failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
@@ skipping 427 matching lines @@
     scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless(window));
     if (!surface->Initialize())
       return NULL;
     return surface;
   }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window) {
     scoped_refptr<NativeViewGLSurfaceEGL> surface;
     scoped_ptr<VSyncProvider> sync_provider;
 #if defined(USE_OZONE)
+    COMPILE_ASSERT(sizeof(EGLNativeWindowType) >=
+                   sizeof(gfx::AcceleratedWidget),
+                   EGLNativeWindowType_wide_enough);
     window = gfx::SurfaceFactoryOzone::GetInstance()->RealizeAcceleratedWidget(
         window);
     sync_provider =
         gfx::SurfaceFactoryOzone::GetInstance()->CreateVSyncProvider(window);
 #endif
     surface = new NativeViewGLSurfaceEGL(window);
     if(surface->Initialize(sync_provider.Pass()))
       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<GLSurface> surface;
-      if (g_egl_surfaceless_context_supported &&
-         (size.width() == 0 && size.height() == 0)) {
+      if (g_egl_surfaceless_context_supported) {
         surface = new SurfacelessEGL(size);
       } else
         surface = new PbufferGLSurfaceEGL(size);
 
       if (!surface->Initialize())
         return NULL;
       return surface;
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx