Explicit control in tools of ANGLE frontend and backend

tools/gpu/gl/angle/GLTestContext_angle.cpp

Index: tools/gpu/gl/angle/GLTestContext_angle.cpp
diff --git a/tools/gpu/gl/angle/GLTestContext_angle.cpp b/tools/gpu/gl/angle/GLTestContext_angle.cpp
index 8cc6f99c9fde814e8989c31fb5ebfdaee42e06cf..3cd888643b6552500fa350f54a0920c48375d635 100644
--- a/tools/gpu/gl/angle/GLTestContext_angle.cpp
+++ b/tools/gpu/gl/angle/GLTestContext_angle.cpp
@@ -26,6 +26,9 @@
 #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;
@@ -45,7 +48,7 @@ static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) {
     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");
@@ -55,38 +58,25 @@ void* get_angle_egl_display(void* nativeDisplay, bool useGLBackend) {
         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;
+    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;
@@ -101,16 +91,19 @@ private:
     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;

[Brian Osman, 2016/09/29 14:58:23]

nit: Alignment.

[bsalomon, 2016/09/29 16:48:10]

Done.

+    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[] = {
@@ -123,8 +116,7 @@ ANGLEGLContext::ANGLEGLContext(bool useGLBackend)
         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;
@@ -137,8 +129,9 @@ ANGLEGLContext::ANGLEGLContext(bool useGLBackend)
     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);
@@ -224,13 +217,7 @@ GrGLuint ANGLEGLContext::eglImageToExternalTexture(GrEGLImage image) const {
 }
 
 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();
     }
@@ -299,19 +286,9 @@ const GrGLInterface* CreateANGLEGLInterface() {
     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;