Move OpenGL ES 2.0 conformance test support into main tree

gpu/gles2_conform_support/egl/egl.cc

+// Copyright (c) 2011 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 <EGL/egl.h>
+
+#include "ui/gfx/gl/gl_context.h"
+#include "ui/gfx/gl/gl_surface.h"
+#include "base/command_line.h"
+#include "gpu/gles2_conform_support/egl/display.h"
+
+namespace {
+void SetCurrentError(EGLint error_code) {
+}
+
+template<typename T>
+T EglError(EGLint error_code, T return_value) {
+  SetCurrentError(error_code);
+  return return_value;
+}
+
+template<typename T>
+T EglSuccess(T return_value) {
+  SetCurrentError(EGL_SUCCESS);
+  return return_value;
+}
+
+EGLint ValidateDisplay(EGLDisplay dpy) {
+  if (dpy == EGL_NO_DISPLAY)
+    return EGL_BAD_DISPLAY;
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->is_initialized())
+    return EGL_NOT_INITIALIZED;
+
+  return EGL_SUCCESS;
+}
+
+EGLint ValidateDisplayConfig(EGLDisplay dpy, EGLConfig config) {
+  EGLint error_code = ValidateDisplay(dpy);
+  if (error_code != EGL_SUCCESS)
+    return error_code;
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->IsValidConfig(config))
+    return EGL_BAD_CONFIG;
+
+  return EGL_SUCCESS;
+}
+
+EGLint ValidateDisplaySurface(EGLDisplay dpy, EGLSurface surface) {
+  EGLint error_code = ValidateDisplay(dpy);
+  if (error_code != EGL_SUCCESS)
+    return error_code;
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->IsValidSurface(surface))
+    return EGL_BAD_SURFACE;
+
+  return EGL_SUCCESS;
+}
+
+EGLint ValidateDisplayContext(EGLDisplay dpy, EGLContext context) {
+  EGLint error_code = ValidateDisplay(dpy);
+  if (error_code != EGL_SUCCESS)
+    return error_code;
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->IsValidContext(context))
+    return EGL_BAD_CONTEXT;
+
+  return EGL_SUCCESS;
+}
+}  // namespace
+
+extern "C" {
+EGLint eglGetError() {
+  // TODO(alokp): Fix me.
+  return EGL_SUCCESS;
+}
+
+EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id) {
+  return new egl::Display(display_id);
+}
+
+EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) {
+  if (dpy == EGL_NO_DISPLAY)
+    return EglError(EGL_BAD_DISPLAY, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->Initialize())
+    return EglError(EGL_NOT_INITIALIZED, EGL_FALSE);
+
+  int argc = 1;
+  const char* const argv[] = {
+    "dummy"
+  };
+  CommandLine::Init(argc, argv);
+  gfx::GLSurface::InitializeOneOff();
+
+  *major = 1;
+  *minor = 4;
+  return EglSuccess(EGL_TRUE);
+}
+
+EGLBoolean eglTerminate(EGLDisplay dpy) {
+  EGLint error_code = ValidateDisplay(dpy);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  delete display;
+
+  return EglSuccess(EGL_TRUE);
+}
+
+const char* eglQueryString(EGLDisplay dpy, EGLint name) {
+  EGLint error_code = ValidateDisplay(dpy);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, static_cast<const char*>(NULL));
+
+  switch (name) {
+    case EGL_CLIENT_APIS:
+      return EglSuccess("OpenGL_ES");
+    case EGL_EXTENSIONS:
+      return EglSuccess("");
+    case EGL_VENDOR:
+      return EglSuccess("Google Inc.");
+    case EGL_VERSION:
+      return EglSuccess("1.4");
+    default:
+      return EglError(EGL_BAD_PARAMETER, static_cast<const char*>(NULL));
+  }
+}
+
+EGLBoolean eglGetConfigs(EGLDisplay dpy,
+                         EGLConfig* configs,
+                         EGLint config_size,
+                         EGLint* num_config) {
+  EGLint error_code = ValidateDisplay(dpy);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_FALSE);
+
+  if (num_config == NULL)
+    return EglError(EGL_BAD_PARAMETER, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->GetConfigs(configs, config_size, num_config))
+    return EglError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+
+  return EglSuccess(EGL_TRUE);
+}
+
+EGLBoolean eglChooseConfig(EGLDisplay dpy,
+                           const EGLint* attrib_list,
+                           EGLConfig* configs,
+                           EGLint config_size,
+                           EGLint* num_config) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglGetConfigAttrib(EGLDisplay dpy,
+                              EGLConfig config,
+                              EGLint attribute,
+                              EGLint* value) {
+  EGLint error_code = ValidateDisplayConfig(dpy, config);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->GetConfigAttrib(config, attribute, value))
+    return EglError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
+
+  return EglSuccess(EGL_TRUE);
+}
+
+EGLSurface eglCreateWindowSurface(EGLDisplay dpy,
+                                  EGLConfig config,
+                                  EGLNativeWindowType win,
+                                  const EGLint* attrib_list) {
+  EGLint error_code = ValidateDisplayConfig(dpy, config);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_NO_SURFACE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->IsValidNativeWindow(win))
+    return EglError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
+
+  EGLSurface surface = display->CreateWindowSurface(config, win, attrib_list);
+  if (surface == EGL_NO_SURFACE)
+    return EglError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+
+  return EglSuccess(surface);
+}
+
+EGLSurface eglCreatePbufferSurface(EGLDisplay dpy,
+                                   EGLConfig config,
+                                   const EGLint* attrib_list) {
+  return EGL_NO_SURFACE;
+}
+
+EGLSurface eglCreatePixmapSurface(EGLDisplay dpy,
+                                  EGLConfig config,
+                                  EGLNativePixmapType pixmap,
+                                  const EGLint* attrib_list) {
+  return EGL_NO_SURFACE;
+}
+
+EGLBoolean eglDestroySurface(EGLDisplay dpy,
+                             EGLSurface surface) {
+  EGLint error_code = ValidateDisplaySurface(dpy, surface);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  display->DestroySurface(surface);
+  return EglSuccess(EGL_TRUE);
+}
+
+EGLBoolean eglQuerySurface(EGLDisplay dpy,
+                           EGLSurface surface,
+                           EGLint attribute,
+                           EGLint* value) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglBindAPI(EGLenum api) {
+  return EGL_FALSE;
+}
+
+EGLenum eglQueryAPI() {
+  return EGL_OPENGL_ES_API;
+}
+
+EGLBoolean eglWaitClient(void) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglReleaseThread(void) {
+  return EGL_FALSE;
+}
+
+EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy,
+                                            EGLenum buftype,
+                                            EGLClientBuffer buffer,
+                                            EGLConfig config,
+                                            const EGLint* attrib_list) {
+  return EGL_NO_SURFACE;
+}
+
+EGLBoolean eglSurfaceAttrib(EGLDisplay dpy,
+                            EGLSurface surface,
+                            EGLint attribute,
+                            EGLint value) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglBindTexImage(EGLDisplay dpy,
+                           EGLSurface surface,
+                           EGLint buffer) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglReleaseTexImage(EGLDisplay dpy,
+                              EGLSurface surface,
+                              EGLint buffer) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
+  return EGL_FALSE;
+}
+
+EGLContext eglCreateContext(EGLDisplay dpy,
+                            EGLConfig config,
+                            EGLContext share_context,
+                            const EGLint* attrib_list) {
+  EGLint error_code = ValidateDisplayConfig(dpy, config);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_NO_CONTEXT);
+
+  if (share_context != EGL_NO_CONTEXT) {
+    error_code = ValidateDisplayContext(dpy, share_context);
+    if (error_code != EGL_SUCCESS)
+      return EglError(error_code, EGL_NO_CONTEXT);
+  }
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  EGLContext context = display->CreateContext(
+      config, share_context, attrib_list);
+  if (context == EGL_NO_CONTEXT)
+    return EglError(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
+
+  return EglSuccess(context);
+}
+
+EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
+  EGLint error_code = ValidateDisplayContext(dpy, ctx);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  display->DestroyContext(ctx);
+  return EGL_TRUE;
+}
+
+EGLBoolean eglMakeCurrent(EGLDisplay dpy,
+                          EGLSurface draw,
+                          EGLSurface read,
+                          EGLContext ctx) {
+  if (ctx != EGL_NO_CONTEXT) {
+    EGLint error_code = ValidateDisplaySurface(dpy, draw);
+    if (error_code != EGL_SUCCESS)
+      return EglError(error_code, EGL_FALSE);
+    error_code = ValidateDisplaySurface(dpy, read);
+    if (error_code != EGL_SUCCESS)
+      return EglError(error_code, EGL_FALSE);
+    error_code = ValidateDisplayContext(dpy, ctx);
+    if (error_code != EGL_SUCCESS)
+      return EglError(error_code, EGL_FALSE);
+  }
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  if (!display->MakeCurrent(draw, read, ctx))
+    return EglError(EGL_CONTEXT_LOST, EGL_FALSE);
+  return EGL_TRUE;
+}
+
+EGLContext eglGetCurrentContext() {
+  return EGL_NO_CONTEXT;
+}
+
+EGLSurface eglGetCurrentSurface(EGLint readdraw) {
+  return EGL_NO_SURFACE;
+}
+
+EGLDisplay eglGetCurrentDisplay() {
+  return EGL_NO_DISPLAY;
+}
+
+EGLBoolean eglQueryContext(EGLDisplay dpy,
+                           EGLContext ctx,
+                           EGLint attribute,
+                           EGLint* value) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglWaitGL() {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglWaitNative(EGLint engine) {
+  return EGL_FALSE;
+}
+
+EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
+  EGLint error_code = ValidateDisplaySurface(dpy, surface);
+  if (error_code != EGL_SUCCESS)
+    return EglError(error_code, EGL_FALSE);
+
+  egl::Display* display = static_cast<egl::Display*>(dpy);
+  display->SwapBuffers(surface);
+  return EglSuccess(EGL_TRUE);
+}
+
+EGLBoolean eglCopyBuffers(EGLDisplay dpy,
+                          EGLSurface surface,
+                          EGLNativePixmapType target) {
+  return EGL_FALSE;
+}
+
+/* Now, define eglGetProcAddress using the generic function ptr. type */
+__eglMustCastToProperFunctionPointerType
+eglGetProcAddress(const char* procname) {
+  return NULL;
+}
+}  // extern "C"