Explicit control in tools of ANGLE frontend and backend

tools/gpu/gl/angle/GLTestContext_angle.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GLTestContext_angle.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "gl/GrGLDefines.h"
 #include "gl/GrGLUtil.h"
 
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLAssembleInterface.h"
 #include "../ports/SkOSLibrary.h"
 
 #include <EGL/egl.h>
 
 #define EGL_PLATFORM_ANGLE_ANGLE                0x3202
 #define EGL_PLATFORM_ANGLE_TYPE_ANGLE           0x3203
 #define EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE      0x3207
 #define EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE     0x3208
 #define EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE    0x320D
 
+using sk_gpu_test::ANGLEBackend;
+using sk_gpu_test::ANGLEContextVersion;
+
 namespace {
 struct Libs {
     void* fGLLib;
     void* fEGLLib;
 };
 
 static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) {
     const Libs* libs = reinterpret_cast<const Libs*>(ctx);
     GrGLFuncPtr proc = (GrGLFuncPtr) GetProcedureAddress(libs->fGLLib, name);
     if (proc) {
         return proc;
     }
     proc = (GrGLFuncPtr) GetProcedureAddress(libs->fEGLLib, name);
     if (proc) {
         return proc;
     }
     return eglGetProcAddress(name);
 }
 
-void* get_angle_egl_display(void* nativeDisplay, bool useGLBackend) {
+void* get_angle_egl_display(void* nativeDisplay, ANGLEBackend type) {
     PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT;
     eglGetPlatformDisplayEXT =
         (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
 
     // We expect ANGLE to support this extension
     if (!eglGetPlatformDisplayEXT) {
         return EGL_NO_DISPLAY;
     }
 
-    EGLDisplay display = EGL_NO_DISPLAY;
-    if (useGLBackend) {
-        EGLint attribs[3] = {
-            EGL_PLATFORM_ANGLE_TYPE_ANGLE,
-            EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE,
-            EGL_NONE
-        };
-        display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, nativeDisplay, attribs);
-    } else {
-        // Try for an ANGLE D3D11 context, fall back to D3D9.
-        EGLint attribs[3][3] = {
-            {
-                EGL_PLATFORM_ANGLE_TYPE_ANGLE,
-                EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
-                EGL_NONE
-            },
-            {
-                EGL_PLATFORM_ANGLE_TYPE_ANGLE,
-                EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE,
-                EGL_NONE
-            },
-        };
-        for (int i = 0; i < 3 && display == EGL_NO_DISPLAY; ++i) {
-            display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,nativeDisplay, attribs[i]);
-        }
+    EGLint typeNum = 0;
+    switch (type) {
+        case ANGLEBackend::kD3D9:
+            typeNum = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
+            break;
+        case ANGLEBackend::kD3D11:
+            typeNum = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
+            break;
+        case ANGLEBackend::kOpenGL:
+            typeNum = EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
+            break;
     }
-    return display;
+    const EGLint attribs[] = { EGL_PLATFORM_ANGLE_TYPE_ANGLE, typeNum, EGL_NONE };
+    return eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, nativeDisplay, attribs);
 }
 
 class ANGLEGLContext : public sk_gpu_test::GLTestContext {
 public:
-    ANGLEGLContext(bool preferGLBackend);
+    ANGLEGLContext(ANGLEBackend, ANGLEContextVersion);
     ~ANGLEGLContext() override;
 
     GrEGLImage texture2DToEGLImage(GrGLuint texID) const override;
     void destroyEGLImage(GrEGLImage) const override;
     GrGLuint eglImageToExternalTexture(GrEGLImage) const override;
     sk_gpu_test::GLTestContext* createNew() const override;
 
 private:
     void destroyGLContext();
 
     void onPlatformMakeCurrent() const override;
     void onPlatformSwapBuffers() const override;
     GrGLFuncPtr onPlatformGetProcAddress(const char* name) const override;
 
-    void* fContext;
-    void* fDisplay;
-    void* fSurface;
-    bool  fIsGLBackend;
+    void*                       fContext;
+    void*                       fDisplay;
+    void*                       fSurface;
+    ANGLEBackend                fType;
+    ANGLEContextVersion         fVersion;
 };
 
-ANGLEGLContext::ANGLEGLContext(bool useGLBackend)
+ANGLEGLContext::ANGLEGLContext(ANGLEBackend type, ANGLEContextVersion version)
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
-    , fSurface(EGL_NO_SURFACE) {
+    , fSurface(EGL_NO_SURFACE)
+    , fType(type)
+    , fVersion(version) {
 
     EGLint numConfigs;
     static const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE, EGL_PBUFFER_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
     };
 
-    fIsGLBackend = useGLBackend;
-    fDisplay = get_angle_egl_display(EGL_DEFAULT_DISPLAY, useGLBackend);
+    fDisplay = get_angle_egl_display(EGL_DEFAULT_DISPLAY, type);
     if (EGL_NO_DISPLAY == fDisplay) {
         SkDebugf("Could not create EGL display!");
         return;
     }
 
     EGLint majorVersion;
     EGLint minorVersion;
     eglInitialize(fDisplay, &majorVersion, &minorVersion);
 
     EGLConfig surfaceConfig;
     eglChooseConfig(fDisplay, configAttribs, &surfaceConfig, 1, &numConfigs);
 
-    static const EGLint contextAttribs[] = {
-        EGL_CONTEXT_CLIENT_VERSION, 2,
+    int versionNum = ANGLEContextVersion::kES2 == version ? 2 : 3;
+    const EGLint contextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, versionNum,
         EGL_NONE
     };
     fContext = eglCreateContext(fDisplay, surfaceConfig, nullptr, contextAttribs);
 
 
     static const EGLint surfaceAttribs[] = {
         EGL_WIDTH, 1,
         EGL_HEIGHT, 1,
         EGL_NONE
     };
@@ skipping 65 matching lines @@
     }
     glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image);
     if (GR_GL_GET_ERROR(this->gl()) != GR_GL_NO_ERROR) {
         GR_GL_CALL(this->gl(), DeleteTextures(1, &texID));
         return 0;
     }
     return texID;
 }
 
 sk_gpu_test::GLTestContext* ANGLEGLContext::createNew() const {
-#ifdef SK_BUILD_FOR_WIN
-    sk_gpu_test::GLTestContext* ctx = fIsGLBackend
-        ? sk_gpu_test::CreateANGLEOpenGLGLTestContext()
-        : sk_gpu_test::CreateANGLEDirect3DGLTestContext();
-#else
-    sk_gpu_test::GLTestContext* ctx = sk_gpu_test::CreateANGLEOpenGLGLTestContext();
-#endif
+    sk_gpu_test::GLTestContext* ctx = sk_gpu_test::CreateANGLETestContext(fType, fVersion);
     if (ctx) {
         ctx->makeCurrent();
     }
     return ctx;
 }
 
 void ANGLEGLContext::destroyGLContext() {
     if (fDisplay) {
         eglMakeCurrent(fDisplay, 0, 0, 0);
 
@@ skipping 48 matching lines @@
     }
 
     if (nullptr == gLibs.fGLLib || nullptr == gLibs.fEGLLib) {
         // We can't setup the interface correctly w/o the so
         return nullptr;
     }
 
     return GrGLAssembleGLESInterface(&gLibs, angle_get_gl_proc);
 }
 
-#ifdef SK_BUILD_FOR_WIN
-GLTestContext* CreateANGLEDirect3DGLTestContext() {
-        ANGLEGLContext* ctx = new ANGLEGLContext(false);
-        if (!ctx->isValid()) {
-            delete ctx;
-            return NULL;
-        }
-        return ctx;
-    }
-#endif
-
-GLTestContext* CreateANGLEOpenGLGLTestContext() {
-    ANGLEGLContext* ctx = new ANGLEGLContext(true);
+GLTestContext* CreateANGLETestContext(ANGLEBackend type,
+                                      ANGLEContextVersion version) {
+    ANGLEGLContext* ctx = new ANGLEGLContext(type, version);
     if (!ctx->isValid()) {
         delete ctx;
         return NULL;
     }
     return ctx;
 }
 }  // namespace sk_gpu_test