Move SkGLContext and some GrGLInterface implementations to skgputest module

src/views/win/SkOSWindow_win.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkTypes.h"
 
 #if defined(SK_BUILD_FOR_WIN)
 
 #include <GL/gl.h>
 #include <WindowsX.h>
 #include "win/SkWGL.h"
 #include "SkWindow.h"
 #include "SkCanvas.h"
 #include "SkOSMenu.h"
 #include "SkTime.h"
 #include "SkUtils.h"
 
 #include "SkGraphics.h"
 
 #if SK_ANGLE
-#include "gl/angle/SkANGLEGLContext.h"
+#include "gl/GrGLAssembleInterface.h"
 #include "gl/GrGLInterface.h"
 #include "GLES2/gl2.h"
-
-#define ANGLE_GL_CALL(IFACE, X)                                 \
-    do {                                                        \
-        (IFACE)->fFunctions.f##X;                               \
-    } while (false)
-
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
 #endif // SK_ANGLE
 
 #if SK_COMMAND_BUFFER
 #include "gl/command_buffer/SkCommandBufferGLContext.h"
+#endif // SK_COMMAND_BUFFER
 
-#define COMMAND_BUFFER_GL_CALL(IFACE, X)                                 \
-    do {                                                        \
-        (IFACE)->fFunctions.f##X;                               \
+#define GL_CALL(IFACE, X)                                 \
+    SkASSERT(IFACE);                                      \
+    do {                                                  \
+        (IFACE)->fFunctions.f##X;                         \
     } while (false)
 
-#endif // SK_COMMAND_BUFFER
-
 #define WM_EVENT_CALLBACK (WM_USER+0)
 
 void post_skwinevent(HWND hwnd)
 {
     PostMessage(hwnd, WM_EVENT_CALLBACK, 0, 0);
 }
 
 SkTHashMap<void*, SkOSWindow*> SkOSWindow::gHwndToOSWindowMap;
 
 SkOSWindow::SkOSWindow(const void* winInit) {
@@ skipping 334 matching lines @@
 }
 
 void SkOSWindow::presentGL() {
     HDC dc = GetDC((HWND)fHWND);
     SwapBuffers(dc);
     ReleaseDC((HWND)fHWND, dc);
 }
 
 #if SK_ANGLE
 
+static void* get_angle_egl_display(void* nativeDisplay) {
+    PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT;
+    eglGetPlatformDisplayEXT =
+        (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
+
+    // We expect ANGLE to support this extension
+    if (!eglGetPlatformDisplayEXT) {
+        return EGL_NO_DISPLAY;
+    }
+
+    EGLDisplay display = EGL_NO_DISPLAY;
+    // Try for an ANGLE D3D11 context, fall back to D3D9, and finally GL.
+    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]);
+    }
+    return display;
+}
+
+struct ANGLEAssembleContext {
+    ANGLEAssembleContext() {
+        fEGL = GetModuleHandle("libEGL.dll");
+        fGL = GetModuleHandle("libEGLESv2.dll");
+    }
+
+    bool isValid() const { return SkToBool(fEGL) && SkToBool(fGL); }
+
+    HMODULE fEGL;
+    HMODULE fGL;
+};
+
+static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) {
+    const ANGLEAssembleContext& context = *reinterpret_cast<const ANGLEAssembleContext*>(ctx);
+    GrGLFuncPtr proc = (GrGLFuncPtr) GetProcAddress(context.fGL, name);
+    if (proc) {
+        return proc;
+    }
+    proc = (GrGLFuncPtr) GetProcAddress(context.fEGL, name);
+    if (proc) {
+        return proc;
+    }
+    return eglGetProcAddress(name);
+}
+
+static const GrGLInterface* get_angle_gl_interface() {
+    ANGLEAssembleContext context;
+    if (!context.isValid()) {
+        return nullptr;
+    }
+    return GrGLAssembleGLESInterface(&context, angle_get_gl_proc);
+}
+
 bool create_ANGLE(EGLNativeWindowType hWnd,
                   int msaaSampleCount,
                   EGLDisplay* eglDisplay,
                   EGLContext* eglContext,
                   EGLSurface* eglSurface,
                   EGLConfig* eglConfig) {
     static const EGLint contextAttribs[] = {
         EGL_CONTEXT_CLIENT_VERSION, 2,
         EGL_NONE, EGL_NONE
     };
     static const EGLint configAttribList[] = {
         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_NONE
     };
     static const EGLint surfaceAttribList[] = {
         EGL_NONE, EGL_NONE
     };
 
-    EGLDisplay display = SkANGLEGLContext::GetD3DEGLDisplay(GetDC(hWnd), false);
+    EGLDisplay display = get_angle_egl_display(GetDC(hWnd));
 
     if (EGL_NO_DISPLAY == display) {
         SkDebugf("Could not create ANGLE egl display!\n");
         return false;
     }
 
     // Initialize EGL
     EGLint majorVersion, minorVersion;
     if (!eglInitialize(display, &majorVersion, &minorVersion)) {
        return false;
@@ skipping 61 matching lines @@
     if (EGL_NO_DISPLAY == fDisplay) {
         bool bResult = create_ANGLE((HWND)fHWND,
                                     msaaSampleCount,
                                     &fDisplay,
                                     &fContext,
                                     &fSurface,
                                     &fConfig);
         if (false == bResult) {
             return false;
         }
-        SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
-
-        if (intf) {
-            ANGLE_GL_CALL(intf, ClearStencil(0));
-            ANGLE_GL_CALL(intf, ClearColor(0, 0, 0, 0));
-            ANGLE_GL_CALL(intf, StencilMask(0xffffffff));
-            ANGLE_GL_CALL(intf, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
+        fANGLEInterface.reset(get_angle_gl_interface());
+        if (!fANGLEInterface) {
+            this->detachANGLE();
+            return false;
         }
-    }
-    if (eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
+        GL_CALL(fANGLEInterface, ClearStencil(0));
+        GL_CALL(fANGLEInterface, ClearColor(0, 0, 0, 0));
+        GL_CALL(fANGLEInterface, StencilMask(0xffffffff));
+        GL_CALL(fANGLEInterface, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
+        if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
+            this->detachANGLE();
+            return false;
+        }
         eglGetConfigAttrib(fDisplay, fConfig, EGL_STENCIL_SIZE, &info->fStencilBits);
         eglGetConfigAttrib(fDisplay, fConfig, EGL_SAMPLES, &info->fSampleCount);
 
-        SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
-
-        if (intf ) {
-            ANGLE_GL_CALL(intf, Viewport(0, 0,
-                                         SkScalarRoundToInt(this->width()),
-                                         SkScalarRoundToInt(this->height())));
-        }
+        GL_CALL(fANGLEInterface, Viewport(0, 0, SkScalarRoundToInt(this->width()),
+                                                SkScalarRoundToInt(this->height())));
         return true;
     }
     return false;
 }
 
 void SkOSWindow::detachANGLE() {
+    fANGLEInterface.reset(nullptr);
     eglMakeCurrent(fDisplay, EGL_NO_SURFACE , EGL_NO_SURFACE , EGL_NO_CONTEXT);
 
     eglDestroyContext(fDisplay, fContext);
     fContext = EGL_NO_CONTEXT;
 
     eglDestroySurface(fDisplay, fSurface);
     fSurface = EGL_NO_SURFACE;
 
     eglTerminate(fDisplay);
     fDisplay = EGL_NO_DISPLAY;
 }
 
 void SkOSWindow::presentANGLE() {
-    SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
-
-    if (intf) {
-        ANGLE_GL_CALL(intf, Flush());
-    }
+    GL_CALL(fANGLEInterface, Flush());
 
     eglSwapBuffers(fDisplay, fSurface);
 }
 #endif // SK_ANGLE
 
 #if SK_COMMAND_BUFFER
 
 bool SkOSWindow::attachCommandBuffer(int msaaSampleCount, AttachmentInfo* info) {
     if (!fCommandBuffer) {
         fCommandBuffer = SkCommandBufferGLContext::Create((HWND)fHWND, msaaSampleCount);
         if (!fCommandBuffer)
             return false;
 
         SkAutoTUnref<const GrGLInterface> intf(GrGLCreateCommandBufferInterface());
         if (intf) {
-            COMMAND_BUFFER_GL_CALL(intf, ClearStencil(0));
-            COMMAND_BUFFER_GL_CALL(intf, ClearColor(0, 0, 0, 0));
-            COMMAND_BUFFER_GL_CALL(intf, StencilMask(0xffffffff));
-            COMMAND_BUFFER_GL_CALL(intf, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
+            GL_CALL(intf, ClearStencil(0));
+            GL_CALL(intf, ClearColor(0, 0, 0, 0));
+            GL_CALL(intf, StencilMask(0xffffffff));
+            GL_CALL(intf, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
         }
     }
 
     if (fCommandBuffer->makeCurrent()) {
         info->fStencilBits = fCommandBuffer->getStencilBits();
         info->fSampleCount = fCommandBuffer->getSampleCount();
 
         SkAutoTUnref<const GrGLInterface> intf(GrGLCreateCommandBufferInterface());
 
         if (intf ) {
-            COMMAND_BUFFER_GL_CALL(intf, Viewport(0, 0,
-                                         SkScalarRoundToInt(this->width()),
+            GL_CALL(intf, Viewport(0, 0, SkScalarRoundToInt(this->width()),
                                          SkScalarRoundToInt(this->height())));
         }
         return true;
     }
     return false;
 }
 
 void SkOSWindow::detachCommandBuffer() {
     delete fCommandBuffer;
     fCommandBuffer = nullptr;
@@ skipping 182 matching lines @@
 }
 
 void SkOSWindow::closeWindow() {
     DestroyWindow((HWND)fHWND);
     if (fFullscreen) {
         DestroyWindow((HWND)fSavedWindowState.fHWND);
     }
     gHwndToOSWindowMap.remove(fHWND);
 }
 #endif