Revert of Implement support for using GL ES 3.0 with command buffer

src/gpu/gl/command_buffer/SkCommandBufferGLContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOnce.h"
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLAssembleInterface.h"
@@ skipping 15 matching lines @@
 typedef void (*__eglMustCastToProperFunctionPointerType)(void);
 #define EGL_FALSE 0
 #define EGL_OPENGL_ES2_BIT 0x0004
 #define EGL_CONTEXT_CLIENT_VERSION 0x3098
 #define EGL_NO_SURFACE ((EGLSurface)0)
 #define EGL_NO_DISPLAY ((EGLDisplay)0)
 #define EGL_NO_CONTEXT ((EGLContext)0)
 #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
 #define EGL_SURFACE_TYPE 0x3033
 #define EGL_PBUFFER_BIT 0x0001
-#define EGL_WINDOW_BIT 0x0004
 #define EGL_RENDERABLE_TYPE 0x3040
 #define EGL_RED_SIZE 0x3024
 #define EGL_GREEN_SIZE 0x3023
 #define EGL_BLUE_SIZE 0x3022
 #define EGL_ALPHA_SIZE 0x3021
 #define EGL_DEPTH_SIZE 0x3025
 #define EGL_STENCIL_SIZE 0x3025
 #define EGL_SAMPLES 0x3031
 #define EGL_SAMPLE_BUFFERS 0x3032
 #define EGL_NONE 0x3038
 #define EGL_WIDTH 0x3057
 #define EGL_HEIGHT 0x3056
 
 #else
 
 #include <EGL/egl.h>
 
 #endif
 
-#ifndef EGL_OPENGL_ES3_BIT
-// Part of EGL 1.5, typical headers are 1.4.
-#define EGL_OPENGL_ES3_BIT 0x0040
-#endif
-
 typedef EGLDisplay (*GetDisplayProc)(EGLNativeDisplayType display_id);
 typedef EGLBoolean (*InitializeProc)(EGLDisplay dpy, EGLint *major, EGLint *minor);
 typedef EGLBoolean (*TerminateProc)(EGLDisplay dpy);
 typedef EGLBoolean (*ChooseConfigProc)(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
 typedef EGLBoolean (*GetConfigAttrib)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
 typedef EGLSurface (*CreateWindowSurfaceProc)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list);
 typedef EGLSurface (*CreatePbufferSurfaceProc)(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
 typedef EGLBoolean (*DestroySurfaceProc)(EGLDisplay dpy, EGLSurface surface);
 typedef EGLContext (*CreateContextProc)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list);
 typedef EGLBoolean (*DestroyContextProc)(EGLDisplay dpy, EGLContext ctx);
@@ skipping 65 matching lines @@
 }
 
 const GrGLInterface* GrGLCreateCommandBufferInterface() {
     LoadCommandBufferOnce();
     if (!gfFunctionsLoadedSuccessfully) {
         return nullptr;
     }
     return GrGLAssembleGLESInterface(gLibrary, command_buffer_get_gl_proc);
 }
 
-SkCommandBufferGLContext::SkCommandBufferGLContext(ContextVersion minContextVersion)
+SkCommandBufferGLContext::SkCommandBufferGLContext()
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
     , fSurface(EGL_NO_SURFACE) {
 
     static const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
-        EGL_RENDERABLE_TYPE,  minContextVersion == kGLES3_ContextVersion ? EGL_OPENGL_ES3_BIT
-                                                                         : EGL_OPENGL_ES2_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
         EGL_RED_SIZE, 8,
         EGL_GREEN_SIZE, 8,
         EGL_BLUE_SIZE, 8,
         EGL_ALPHA_SIZE, 8,
         EGL_NONE
     };
 
     static const EGLint surfaceAttribs[] = {
         EGL_WIDTH, 1,
         EGL_HEIGHT, 1,
         EGL_NONE
     };
 
-    initializeGLContext(minContextVersion, nullptr, configAttribs, surfaceAttribs);
+    initializeGLContext(nullptr, configAttribs, surfaceAttribs);
 }
 
 SkCommandBufferGLContext::SkCommandBufferGLContext(void* nativeWindow, int msaaSampleCount) {
     static const EGLint surfaceAttribs[] = { EGL_NONE };
 
     EGLint configAttribs[] = {
-        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
         EGL_RED_SIZE,       8,
         EGL_GREEN_SIZE,     8,
         EGL_BLUE_SIZE,      8,
         EGL_ALPHA_SIZE,     8,
         EGL_DEPTH_SIZE,     8,
         EGL_STENCIL_SIZE,   8,
         EGL_SAMPLE_BUFFERS, 1,
         EGL_SAMPLES,        msaaSampleCount,
         EGL_NONE
     };
     if (msaaSampleCount == 0) {
         configAttribs[12] = EGL_NONE;
     }
 
-    initializeGLContext(kGLES2_ContextVersion, nativeWindow, configAttribs, surfaceAttribs);
+    initializeGLContext(nativeWindow, configAttribs, surfaceAttribs);
 }
 
-void SkCommandBufferGLContext::initializeGLContext(ContextVersion minContextVersion,
-                                                   void* nativeWindow, const int* configAttribs,
+void SkCommandBufferGLContext::initializeGLContext(void* nativeWindow, const int* configAttribs,
                                                    const int* surfaceAttribs) {
     LoadCommandBufferOnce();
     if (!gfFunctionsLoadedSuccessfully) {
         SkDebugf("Command Buffer: Could not load EGL functions.\n");
         return;
     }
 
     // Make sure CHROMIUM_path_rendering is enabled for NVPR support.
-    sk_setenv("CHROME_COMMAND_BUFFER_GLES2_ARGS", "--enable-gl-path-rendering --enable-unsafe-es3-apis");
+    sk_setenv("CHROME_COMMAND_BUFFER_GLES2_ARGS", "--enable-gl-path-rendering");
     fDisplay = gfGetDisplay(EGL_DEFAULT_DISPLAY);
     if (EGL_NO_DISPLAY == fDisplay) {
         SkDebugf("Command Buffer: Could not create EGL display.\n");
         return;
     }
 
-    if (!gfInitialize(fDisplay, nullptr, nullptr)) {
+    EGLint majorVersion;
+    EGLint minorVersion;
+    if (!gfInitialize(fDisplay, &majorVersion, &minorVersion)) {
         SkDebugf("Command Buffer: Could not initialize EGL display.\n");
         this->destroyGLContext();
         return;
     }
 
     EGLint numConfigs;
     if (!gfChooseConfig(fDisplay, configAttribs, static_cast<EGLConfig*>(&fConfig), 1,
-                        &numConfigs) || numConfigs < 1) {
+                        &numConfigs) || numConfigs != 1) {
         SkDebugf("Command Buffer: Could not choose EGL config.\n");
         this->destroyGLContext();
         return;
     }
 
     if (nativeWindow) {
         fSurface = gfCreateWindowSurface(fDisplay,
                                          static_cast<EGLConfig>(fConfig),
                                          (EGLNativeWindowType)nativeWindow,
                                          surfaceAttribs);
     } else {
         fSurface = gfCreatePbufferSurface(fDisplay,
                                           static_cast<EGLConfig>(fConfig),
                                           surfaceAttribs);
     }
     if (EGL_NO_SURFACE == fSurface) {
         SkDebugf("Command Buffer: Could not create EGL surface.\n");
         this->destroyGLContext();
         return;
     }
 
     static const EGLint contextAttribs[] = {
-        EGL_CONTEXT_CLIENT_VERSION, minContextVersion == kGLES3_ContextVersion ? 3 : 2,
+        EGL_CONTEXT_CLIENT_VERSION, 2,
         EGL_NONE
     };
     fContext = gfCreateContext(fDisplay, static_cast<EGLConfig>(fConfig), nullptr, contextAttribs);
     if (EGL_NO_CONTEXT == fContext) {
         SkDebugf("Command Buffer: Could not create EGL context.\n");
         this->destroyGLContext();
         return;
     }
 
     if (!gfMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
@@ skipping 19 matching lines @@
 
 SkCommandBufferGLContext::~SkCommandBufferGLContext() {
     this->teardown();
     this->destroyGLContext();
 }
 
 void SkCommandBufferGLContext::destroyGLContext() {
     if (!gfFunctionsLoadedSuccessfully) {
         return;
     }
-    if (EGL_NO_DISPLAY == fDisplay) {
-        return;
+    if (fDisplay) {
+        gfMakeCurrent(fDisplay, 0, 0, 0);
+
+        if (fContext) {
+            gfDestroyContext(fDisplay, fContext);
+            fContext = EGL_NO_CONTEXT;
+        }
+
+        if (fSurface) {
+            gfDestroySurface(fDisplay, fSurface);
+            fSurface = EGL_NO_SURFACE;
+        }
+
+        gfTerminate(fDisplay);
+        fDisplay = EGL_NO_DISPLAY;
     }
-
-    if (EGL_NO_CONTEXT != fContext) {
-        gfDestroyContext(fDisplay, fContext);
-        fContext = EGL_NO_CONTEXT;
-    }
-    // Call MakeCurrent after destroying the context, so that the EGL implementation knows
-    // that the context is not used anymore after it is released from being current.
-    // This way command buffer does not need to abandon the context before destruction, and no
-    // client-side errors are printed.
-    gfMakeCurrent(fDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-
-    if (EGL_NO_SURFACE != fSurface) {
-        gfDestroySurface(fDisplay, fSurface);
-        fSurface = EGL_NO_SURFACE;
-    }
-    // The display is likely to be used again for another test, do not call gfTerminate.  Also,
-    // terminating could imply terminating the "host" EGL inside command buffer. This would
-    // terminate also EGL that this thread might use outside of command buffer.
-    fDisplay = EGL_NO_DISPLAY;
 }
 
 void SkCommandBufferGLContext::onPlatformMakeCurrent() const {
     if (!gfFunctionsLoadedSuccessfully) {
         return;
     }
     if (!gfMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
         SkDebugf("Command Buffer: Could not make EGL context current.\n");
     }
 }
@@ skipping 30 matching lines @@
     EGLint result = 0;
     gfGetConfigAttrib(fDisplay, static_cast<EGLConfig>(fConfig), EGL_STENCIL_SIZE, &result);
     return result;
 }
 
 int SkCommandBufferGLContext::getSampleCount() {
     EGLint result = 0;
     gfGetConfigAttrib(fDisplay, static_cast<EGLConfig>(fConfig), EGL_SAMPLES, &result);
     return result;
 }