Revert of 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, ANGLEBackend type) {
+void* get_angle_egl_display(void* nativeDisplay, bool useGLBackend) {
     PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT;
     eglGetPlatformDisplayEXT =
         (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
 
     // We expect ANGLE to support this extension
     if (!eglGetPlatformDisplayEXT) {
         return EGL_NO_DISPLAY;
     }
 
-    EGLint typeNum;
-    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;
+    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]);
+        }
     }
-    const EGLint attribs[] = { EGL_PLATFORM_ANGLE_TYPE_ANGLE, typeNum, EGL_NONE };
-    return eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, nativeDisplay, attribs);
+    return display;
 }
 
 class ANGLEGLContext : public sk_gpu_test::GLTestContext {
 public:
-    ANGLEGLContext(ANGLEBackend, ANGLEContextVersion);
+    ANGLEGLContext(bool preferGLBackend);
     ~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;
-    ANGLEBackend                fType;
-    ANGLEContextVersion         fVersion;
+    void* fContext;
+    void* fDisplay;
+    void* fSurface;
+    bool  fIsGLBackend;
 };
 
-ANGLEGLContext::ANGLEGLContext(ANGLEBackend type, ANGLEContextVersion version)
+ANGLEGLContext::ANGLEGLContext(bool useGLBackend)
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
-    , fSurface(EGL_NO_SURFACE)
-    , fType(type)
-    , fVersion(version) {
+    , fSurface(EGL_NO_SURFACE) {
 
     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
     };
 
-    fDisplay = get_angle_egl_display(EGL_DEFAULT_DISPLAY, type);
+    fIsGLBackend = useGLBackend;
+    fDisplay = get_angle_egl_display(EGL_DEFAULT_DISPLAY, useGLBackend);
     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);
 
-    int versionNum = ANGLEContextVersion::kES2 == version ? 2 : 3;
-    const EGLint contextAttribs[] = {
-        EGL_CONTEXT_CLIENT_VERSION, versionNum,
+    static const EGLint contextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
         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 {
-    sk_gpu_test::GLTestContext* ctx = sk_gpu_test::CreateANGLETestContext(fType, fVersion);
+#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
     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);
 }
 
-GLTestContext* CreateANGLETestContext(ANGLEBackend type,
-                                      ANGLEContextVersion version) {
-    ANGLEGLContext* ctx = new ANGLEGLContext(type, version);
+#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);
     if (!ctx->isValid()) {
         delete ctx;
         return NULL;
     }
     return ctx;
 }
 }  // namespace sk_gpu_test