wayland patch for inspection

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
 
@@ skipping 10 matching lines @@
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
 }
 #endif
 
 #if defined (USE_OZONE)
 #include "ui/base/ozone/surface_factory_ozone.h"
 #endif
 
+#if defined(USE_WAYLAND)
+#include "ui/wayland/wayland_display.h"
+#include "ui/wayland/wayland_window.h"
+#include <wayland-egl.h>
+#endif
+
 using ui::GetLastEGLErrorString;
 
 namespace gfx {
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 EGLConfig g_software_config;
@@ skipping 46 matching lines @@
 
 bool GLSurfaceEGL::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
 #if defined (USE_OZONE)
   ui::SurfaceFactoryOzone::GetInstance()->InitializeHardware();
 #endif
 
-#if defined(USE_X11)
+#if defined(USE_WAYLAND)
+  g_native_display = ui::WaylandDisplay::GetDisplay()->display();
+#elif defined(USE_X11)
   g_native_display = base::MessagePumpForUI::GetDefaultXDisplay();
 #else
   g_native_display = EGL_DEFAULT_DISPLAY;
 #endif
   g_display = eglGetDisplay(g_native_display);
   if (!g_display) {
     LOG(ERROR) << "eglGetDisplay failed with error " << GetLastEGLErrorString();
     return false;
   }
 
   if (!eglInitialize(g_display, NULL, NULL)) {
     LOG(ERROR) << "eglInitialize failed with error " << GetLastEGLErrorString();
     return false;
   }
 
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
   static const EGLint kConfigAttribs[] = {
     EGL_BUFFER_SIZE, 32,
     EGL_ALPHA_SIZE, 8,
     EGL_BLUE_SIZE, 8,
     EGL_GREEN_SIZE, 8,
     EGL_RED_SIZE, 8,
     EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-    EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+    EGL_SURFACE_TYPE,
+#if defined(USE_WAYLAND)
+    EGL_WINDOW_BIT,
+#else
+    EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+#endif
     EGL_NONE
   };
 
   EGLint num_configs;
   if (!eglChooseConfig(g_display,
                        kConfigAttribs,
                        NULL,
                        0,
                        &num_configs)) {
     LOG(ERROR) << "eglChooseConfig failed with error "
@@ skipping 18 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) \
-    || defined(USE_OZONE)
+    || defined(USE_OZONE) || defined(USE_WAYLAND)
   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 88 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(),
+#if defined(USE_WAYLAND)
+      window_->egl_window(),
+#else
       window_,
+#endif
       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 16 matching lines @@
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
 }
 
 EGLConfig NativeViewGLSurfaceEGL::GetConfig() {
-#if !defined(USE_X11)
+#if !defined(USE_X11) || defined(USE_WAYLAND)
   return software_ ? g_software_config : g_config;
 #else
   if (!config_) {
     // Get a config compatible with the window
     DCHECK(window_);
     XWindowAttributes win_attribs;
     if (!XGetWindowAttributes(GetNativeDisplay(), window_, &win_attribs)) {
       return NULL;
     }
 
@@ skipping 65 matching lines @@
 bool NativeViewGLSurfaceEGL::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceEGL::SwapBuffers() {
   if (!eglSwapBuffers(GetDisplay(), surface_)) {
     DVLOG(1) << "eglSwapBuffers failed with error "
              << GetLastEGLErrorString();
     return false;
   }
-
   return true;
 }
 
 gfx::Size NativeViewGLSurfaceEGL::GetSize() {
   EGLint width;
   EGLint height;
   if (!eglQuerySurface(GetDisplay(), surface_, EGL_WIDTH, &width) ||
       !eglQuerySurface(GetDisplay(), surface_, EGL_HEIGHT, &height)) {
     NOTREACHED() << "eglQuerySurface failed with error "
                  << GetLastEGLErrorString();
     return gfx::Size();
   }
 
   return gfx::Size(width, height);
 }
 
 bool NativeViewGLSurfaceEGL::Resize(const gfx::Size& size) {
+#if defined(USE_WAYLAND)
+  window_->ScheduleResize(size.width(), size.height());
+#endif
   if (size == GetSize())
     return true;
 
   scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
   GLContext* current_context = GLContext::GetCurrent();
   bool was_current =
       current_context && current_context->IsCurrent(this);
   if (was_current) {
     scoped_make_current.reset(
         new ui::ScopedMakeCurrent(current_context, this));
@@ skipping 73 matching lines @@
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
   }
 
   if (size_.GetArea() == 0) {
     LOG(ERROR) << "Error: surface has zero area "
                << size_.width() << " x " << size_.height();
     return false;
   }
 
+#if defined(USE_WAYLAND)
+  wsurf_ = ui::WaylandDisplay::GetDisplay()->CreateSurface();
+  wwindow_ = wl_egl_window_create(wsurf_, size_.width(), size_.height());
+  EGLSurface new_surface = eglCreateWindowSurface(GetDisplay(),
+                                                  GetConfig(),
+                                                  wwindow_,
+                                                  NULL);
+#else
   // Allocate the new pbuffer surface before freeing the old one to ensure
   // they have different addresses. If they have the same address then a
   // future call to MakeCurrent might early out because it appears the current
   // context and surface have not changed.
   const EGLint pbuffer_attribs[] = {
     EGL_WIDTH, size_.width(),
     EGL_HEIGHT, size_.height(),
     EGL_NONE
   };
 
   EGLSurface new_surface = eglCreatePbufferSurface(display,
                                                    GetConfig(),
                                                    pbuffer_attribs);
+#endif
   if (!new_surface) {
     LOG(ERROR) << "eglCreatePbufferSurface failed with error "
                << GetLastEGLErrorString();
     return false;
   }
 
   if (old_surface)
     eglDestroySurface(display, old_surface);
 
   surface_ = new_surface;
@@ skipping 137 matching lines @@
     }
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 #endif
 
 }  // namespace gfx