diff --git a/src/quick/scenegraph/qsgadaptationlayer.cpp b/src/quick/scenegraph/qsgadaptationlayer.cpp
index 9e4b572ea68ceb7fa69e871c680a209c0e2bb879..83704cf0ecc278c34597e0ae333ec4ac64846394 100644
--- a/src/quick/scenegraph/qsgadaptationlayer.cpp
+++ b/src/quick/scenegraph/qsgadaptationlayer.cpp
@@ -294,30 +294,32 @@ void QSGDistanceFieldGlyphCache::updateTexture(GLuint oldTex, GLuint newTex, con
 
 void QSGDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width, int height) const
 {
+    QOpenGLFunctions *functions = QOpenGLContext::currentContext()->functions();
+
     GLuint fboId;
-    glGenFramebuffers(1, &fboId);
+    functions->glGenFramebuffers(1, &fboId);
 
     GLuint tmpTexture = 0;
-    glGenTextures(1, &tmpTexture);
-    glBindTexture(GL_TEXTURE_2D, tmpTexture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glBindTexture(GL_TEXTURE_2D, 0);
-
-    glBindFramebuffer(GL_FRAMEBUFFER_EXT, fboId);
-    glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
-                           tmpTexture, 0);
-
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, textureId);
-
-    glDisable(GL_STENCIL_TEST);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_SCISSOR_TEST);
-    glDisable(GL_BLEND);
+    functions->glGenTextures(1, &tmpTexture);
+    functions->glBindTexture(GL_TEXTURE_2D, tmpTexture);
+    functions->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+    functions->glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    functions->glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    functions->glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    functions->glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    functions->glBindTexture(GL_TEXTURE_2D, 0);
+
+    functions->glBindFramebuffer(GL_FRAMEBUFFER_EXT, fboId);
+    functions->glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
+                                      tmpTexture, 0);
+
+    functions->glActiveTexture(GL_TEXTURE0);
+    functions->glBindTexture(GL_TEXTURE_2D, textureId);
+
+    functions->glDisable(GL_STENCIL_TEST);
+    functions->glDisable(GL_DEPTH_TEST);
+    functions->glDisable(GL_SCISSOR_TEST);
+    functions->glDisable(GL_BLEND);
 
     GLfloat textureCoordinateArray[8];
     textureCoordinateArray[0] = 0.0f;
@@ -339,9 +341,9 @@ void QSGDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width, int he
     vertexCoordinateArray[6] = -1.0f;
     vertexCoordinateArray[7] =  1.0f;
 
-    glViewport(0, 0, width, height);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray);
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray);
+    functions->glViewport(0, 0, width, height);
+    functions->glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray);
+    functions->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray);
 
     {
         static const char *vertexShaderSource =
@@ -362,72 +364,64 @@ void QSGDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width, int he
                 "    gl_FragColor = texture2D(texture, textureCoords); \n"
                 "} \n";
 
-        GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
-        GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+        GLuint vertexShader = functions->glCreateShader(GL_VERTEX_SHADER);
+        GLuint fragmentShader = functions->glCreateShader(GL_FRAGMENT_SHADER);
 
         if (vertexShader == 0 || fragmentShader == 0) {
-            GLenum error = glGetError();
-            qWarning("SharedGraphicsCacheServer::setupShaderPrograms: Failed to create shaders. (GL error: %x)",
+            GLenum error = functions->glGetError();
+            qWarning("QSGDistanceFieldGlyphCache::saveTexture: Failed to create shaders. (GL error: %x)",
                      error);
             return;
         }
 
-        glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
-        glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
-        glCompileShader(vertexShader);
+        functions->glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
+        functions->glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
+        functions->glCompileShader(vertexShader);
 
         GLint len = 1;
-        glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len);
+        functions->glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &len);
 
         char infoLog[2048];
-        glGetShaderInfoLog(vertexShader, 2048, NULL, infoLog);
-        if (qstrlen(infoLog) > 0) {
-            qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems compiling vertex shader:\n %s",
-                     infoLog);
-        }
+        functions->glGetShaderInfoLog(vertexShader, 2048, NULL, infoLog);
+        if (qstrlen(infoLog) > 0)
+            qWarning("Problems compiling vertex shader:\n %s", infoLog);
 
-        glCompileShader(fragmentShader);
-        glGetShaderInfoLog(fragmentShader, 2048, NULL, infoLog);
-        if (qstrlen(infoLog) > 0) {
-            qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems compiling fragent shader:\n %s",
-                     infoLog);
-        }
+        functions->glCompileShader(fragmentShader);
+        functions->glGetShaderInfoLog(fragmentShader, 2048, NULL, infoLog);
+        if (qstrlen(infoLog) > 0)
+            qWarning("Problems compiling fragment shader:\n %s", infoLog);
 
-        GLuint shaderProgram = glCreateProgram();
-        glAttachShader(shaderProgram, vertexShader);
-        glAttachShader(shaderProgram, fragmentShader);
+        GLuint shaderProgram = functions->glCreateProgram();
+        functions->glAttachShader(shaderProgram, vertexShader);
+        functions->glAttachShader(shaderProgram, fragmentShader);
 
-        glBindAttribLocation(shaderProgram, 0, "vertexCoordsArray");
-        glBindAttribLocation(shaderProgram, 1, "textureCoordArray");
+        functions->glBindAttribLocation(shaderProgram, 0, "vertexCoordsArray");
+        functions->glBindAttribLocation(shaderProgram, 1, "textureCoordArray");
 
-        glLinkProgram(shaderProgram);
-        glGetProgramInfoLog(shaderProgram, 2048, NULL, infoLog);
-        if (qstrlen(infoLog) > 0) {
-            qWarning("SharedGraphicsCacheServer::setupShaderPrograms, problems linking shaders:\n %s",
-                     infoLog);
-        }
+        functions->glLinkProgram(shaderProgram);
+        functions->glGetProgramInfoLog(shaderProgram, 2048, NULL, infoLog);
+        if (qstrlen(infoLog) > 0)
+            qWarning("Problems linking shaders:\n %s", infoLog);
 
-        glUseProgram(shaderProgram);
-        glEnableVertexAttribArray(0);
-        glEnableVertexAttribArray(1);
+        functions->glUseProgram(shaderProgram);
+        functions->glEnableVertexAttribArray(0);
+        functions->glEnableVertexAttribArray(1);
 
-        int textureUniformLocation = glGetUniformLocation(shaderProgram, "texture");
-        glUniform1i(textureUniformLocation, 0);
+        int textureUniformLocation = functions->glGetUniformLocation(shaderProgram, "texture");
+        functions->glUniform1i(textureUniformLocation, 0);
     }
 
-    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    functions->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
     {
-        GLenum error = glGetError();
-        if (error != GL_NO_ERROR) {
-            qWarning("SharedGraphicsCacheServer::readBackBuffer: glDrawArrays reported error 0x%x",
-                     error);
-        }
+        GLenum error = functions->glGetError();
+        if (error != GL_NO_ERROR)
+            qWarning("glDrawArrays reported error 0x%x", error);
     }
 
     uchar *data = new uchar[width * height * 4];
 
-    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
+    functions->glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
 
     QImage image(data, width, height, QImage::Format_ARGB32);
 
@@ -437,18 +431,16 @@ void QSGDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width, int he
     image.save(QString::fromLocal8Bit(fileName));
 
     {
-        GLenum error = glGetError();
-        if (error != GL_NO_ERROR) {
-            qWarning("SharedGraphicsCacheServer::readBackBuffer: glReadPixels reported error 0x%x",
-                     error);
-        }
+        GLenum error = functions->glGetError();
+        if (error != GL_NO_ERROR)
+            qWarning("glReadPixels reported error 0x%x", error);
     }
 
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
+    functions->glDisableVertexAttribArray(0);
+    functions->glDisableVertexAttribArray(1);
 
-    glDeleteFramebuffers(1, &fboId);
-    glDeleteTextures(1, &tmpTexture);
+    functions->glDeleteFramebuffers(1, &fboId);
+    functions->glDeleteTextures(1, &tmpTexture);
 
     delete[] data;
 }