Add a factory and defines for native Linux surfaces.

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"
 
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
 }
 #endif
 
+#if defined(USE_NATIVE_SURFACE_LINUX)
+#include "ui/base/linux/native_surface_linux_factory.h"
+#endif
+
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 EGLConfig g_software_config;
@@ skipping 105 matching lines @@
   }
 
   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");
 
   initialized = true;
 
-#if defined(USE_X11) || defined(OS_ANDROID)
+#if defined(USE_X11) || defined(OS_ANDROID)  || defined(USE_NATIVE_SURFACE_LINUX)

[jonathan.backer, 2013/04/30 12:41:20]

nit: use a \ to wrap?

[rjkroege, 2013/05/06 18:46:24]

Done.

   return true;
 #else
   g_software_native_display = EGL_SOFTWARE_DISPLAY_ANGLE;
 #endif
   g_software_display = eglGetDisplay(g_software_native_display);
   if (!g_software_display) {
     return true;
   }
 
   if (!eglInitialize(g_software_display, NULL, NULL)) {
@@ skipping 56 matching lines @@
 
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(bool software,
                                                gfx::AcceleratedWidget window)
     : window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL) {
   software_ = software;
+
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
   DCHECK(!surface_);
 
   if (window_ == kNullAcceleratedWidget) {
@@ skipping 13 matching lines @@
 
   // Create a surface for the native window.
   surface_ = eglCreateWindowSurface(
       GetDisplay(),
       GetConfig(),
       window_,
       gfx::g_driver_egl.ext.b_EGL_NV_post_sub_buffer ?
           egl_window_attributes_sub_buffer :
           NULL);
 
+#if defined(USE_NATIVE_SURFACE_LINUX)
+  eglSurfaceAttrib(GetDisplay(), surface_,
+                   EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
+#endif
+
   if (!surface_) {
     LOG(ERROR) << "eglCreateWindowSurface failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
 
   EGLint surfaceVal;
   EGLBoolean retVal = eglQuerySurface(GetDisplay(),
                                       surface_,
@@ skipping 118 matching lines @@
     return gfx::Size();
   }
 
   return gfx::Size(width, height);
 }
 
 bool NativeViewGLSurfaceEGL::Resize(const gfx::Size& size) {
   if (size == GetSize())
     return true;
 
+#if defined(USE_NATIVE_SURFACE_LINUX)
+  ui::NativeSurfaceLinuxFactory *nslf =
+      ui::NativeSurfaceLinuxFactory::GetInstance();
+  if (!nslf->AcceleratedWidgetCanBeResized(window_)) {
+    LOG(ERROR) << "desired size for GL surface does not match native size";
+    LOG(ERROR) << "desired size: " << size.width() << "x" << size.height();
+    LOG(ERROR) << "native size: " << GetSize().width() << "x"
+        << GetSize().height();
+    return true;
+  }
+#endif
+
   GLContext* current_context = GLContext::GetCurrent();
   bool was_current = current_context && current_context->IsCurrent(this);
   if (was_current)
     current_context->ReleaseCurrent(this);
 
   Destroy();
 
   if (!Initialize()) {
     LOG(ERROR) << "Failed to resize pbuffer.";
     return false;
@@ skipping 172 matching lines @@
 
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
 }  // namespace gfx