Pass Context to Query Impl methods.

src/libANGLE/Context.cpp

@@ -107,18 +107,21 @@ std::vector<gl::Path *> GatherPaths(gl::PathManager &resourceManager,
 }
 
 template <typename T>
-gl::Error GetQueryObjectParameter(gl::Query *query, GLenum pname, T *params)
+gl::Error GetQueryObjectParameter(const gl::Context *context,
+                                  gl::Query *query,
+                                  GLenum pname,
+                                  T *params)
 {
     ASSERT(query != nullptr);
 
     switch (pname)
     {
         case GL_QUERY_RESULT_EXT:
-            return query->getResult(params);
+            return query->getResult(context, params);
         case GL_QUERY_RESULT_AVAILABLE_EXT:
         {
             bool available;
-            gl::Error error = query->isResultAvailable(&available);
+            gl::Error error = query->isResultAvailable(context, &available);
             if (!error.isError())
             {
                 *params = gl::CastFromStateValue<T>(pname, static_cast<GLuint>(available));
@@ -1147,7 +1150,7 @@ void Context::beginQuery(QueryType target, GLuint query)
     ASSERT(queryObject);
 
     // begin query
-    ANGLE_CONTEXT_TRY(queryObject->begin());
+    ANGLE_CONTEXT_TRY(queryObject->begin(this));
 
     // set query as active for specified target only if begin succeeded
     mGLState.setActiveQuery(this, target, queryObject);
@@ -1158,7 +1161,7 @@ void Context::endQuery(QueryType target)
     Query *queryObject = mGLState.getActiveQuery(target);
     ASSERT(queryObject);
 
-    handleError(queryObject->end());
+    handleError(queryObject->end(this));
 
     // Always unbind the query, even if there was an error. This may delete the query object.
     mGLState.setActiveQuery(this, target, nullptr);
@@ -1171,7 +1174,7 @@ void Context::queryCounter(GLuint id, QueryType target)
     Query *queryObject = getQuery(id, true, target);
     ASSERT(queryObject);
 
-    handleError(queryObject->queryCounter());
+    handleError(queryObject->queryCounter(this));
 }
 
 void Context::getQueryiv(QueryType target, GLenum pname, GLint *params)
@@ -1213,7 +1216,7 @@ void Context::getQueryivRobust(QueryType target,
 
 void Context::getQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    handleError(GetQueryObjectParameter(getQuery(id), pname, params));
+    handleError(GetQueryObjectParameter(this, getQuery(id), pname, params));
 }
 
 void Context::getQueryObjectivRobust(GLuint id,
@@ -1227,7 +1230,7 @@ void Context::getQueryObjectivRobust(GLuint id,
 
 void Context::getQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    handleError(GetQueryObjectParameter(getQuery(id), pname, params));
+    handleError(GetQueryObjectParameter(this, getQuery(id), pname, params));
 }
 
 void Context::getQueryObjectuivRobust(GLuint id,
@@ -1241,7 +1244,7 @@ void Context::getQueryObjectuivRobust(GLuint id,
 
 void Context::getQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    handleError(GetQueryObjectParameter(getQuery(id), pname, params));
+    handleError(GetQueryObjectParameter(this, getQuery(id), pname, params));
 }
 
 void Context::getQueryObjecti64vRobust(GLuint id,
@@ -1255,7 +1258,7 @@ void Context::getQueryObjecti64vRobust(GLuint id,
 
 void Context::getQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    handleError(GetQueryObjectParameter(getQuery(id), pname, params));
+    handleError(GetQueryObjectParameter(this, getQuery(id), pname, params));
 }
 
 void Context::getQueryObjectui64vRobust(GLuint id,

src/libANGLE/Query.cpp

@@ -30,44 +30,44 @@ const std::string &Query::getLabel() const
     return mLabel;
 }
 
-Error Query::begin()
+Error Query::begin(const Context *context)
 {
-    return mQuery->begin();
+    return mQuery->begin(context);
 }
 
-Error Query::end()
+Error Query::end(const Context *context)
 {
-    return mQuery->end();
+    return mQuery->end(context);
 }
 
-Error Query::queryCounter()
+Error Query::queryCounter(const Context *context)
 {
-    return mQuery->queryCounter();
+    return mQuery->queryCounter(context);
 }
 
-Error Query::getResult(GLint *params)
+Error Query::getResult(const Context *context, GLint *params)
 {
-    return mQuery->getResult(params);
+    return mQuery->getResult(context, params);
 }
 
-Error Query::getResult(GLuint *params)
+Error Query::getResult(const Context *context, GLuint *params)
 {
-    return mQuery->getResult(params);
+    return mQuery->getResult(context, params);
 }
 
-Error Query::getResult(GLint64 *params)
+Error Query::getResult(const Context *context, GLint64 *params)
 {
-    return mQuery->getResult(params);
+    return mQuery->getResult(context, params);
 }
 
-Error Query::getResult(GLuint64 *params)
+Error Query::getResult(const Context *context, GLuint64 *params)
 {
-    return mQuery->getResult(params);
+    return mQuery->getResult(context, params);
 }
 
-Error Query::isResultAvailable(bool *available)
+Error Query::isResultAvailable(const Context *context, bool *available)
 {
-    return mQuery->isResultAvailable(available);
+    return mQuery->isResultAvailable(context, available);
 }
 
 QueryType Query::getType() const

src/libANGLE/Query.h

@@ -36,14 +36,14 @@ class Query final : public RefCountObject, public LabeledObject
     void setLabel(const std::string &label) override;
     const std::string &getLabel() const override;
 
-    Error begin();
-    Error end();
-    Error queryCounter();
-    Error getResult(GLint *params);
-    Error getResult(GLuint *params);
-    Error getResult(GLint64 *params);
-    Error getResult(GLuint64 *params);
-    Error isResultAvailable(bool *available);
+    Error begin(const Context *context);
+    Error end(const Context *context);
+    Error queryCounter(const Context *context);
+    Error getResult(const Context *context, GLint *params);
+    Error getResult(const Context *context, GLuint *params);
+    Error getResult(const Context *context, GLint64 *params);
+    Error getResult(const Context *context, GLuint64 *params);
+    Error isResultAvailable(const Context *context, bool *available);
 
     QueryType getType() const;
 

src/libANGLE/renderer/QueryImpl.h

@@ -13,29 +13,33 @@
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
 
-namespace rx
+namespace gl
 {
+class Context;
+}  // namespace gl
 
+namespace rx
+{
 class QueryImpl : angle::NonCopyable
 {
   public:
-    explicit QueryImpl(gl::QueryType type) { mType = type; }
+    explicit QueryImpl(gl::QueryType type) : mType(type) {}
     virtual ~QueryImpl() {}
 
-    virtual gl::Error begin()                            = 0;
-    virtual gl::Error end()                              = 0;
-    virtual gl::Error queryCounter()                     = 0;
-    virtual gl::Error getResult(GLint *params)           = 0;
-    virtual gl::Error getResult(GLuint *params)          = 0;
-    virtual gl::Error getResult(GLint64 *params)         = 0;
-    virtual gl::Error getResult(GLuint64 *params)        = 0;
-    virtual gl::Error isResultAvailable(bool *available) = 0;
+    virtual gl::Error begin(const gl::Context *context)                              = 0;
+    virtual gl::Error end(const gl::Context *context)                                = 0;
+    virtual gl::Error queryCounter(const gl::Context *context)                       = 0;
+    virtual gl::Error getResult(const gl::Context *context, GLint *params)           = 0;
+    virtual gl::Error getResult(const gl::Context *context, GLuint *params)          = 0;
+    virtual gl::Error getResult(const gl::Context *context, GLint64 *params)         = 0;
+    virtual gl::Error getResult(const gl::Context *context, GLuint64 *params)        = 0;
+    virtual gl::Error isResultAvailable(const gl::Context *context, bool *available) = 0;
 
     gl::QueryType getType() const { return mType; }
 
   private:
     gl::QueryType mType;
 };
-}
+}  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_QUERYIMPL_H_

src/libANGLE/renderer/d3d/d3d11/Query11.cpp

@@ -68,19 +68,19 @@ Query11::~Query11()
     mRenderer->getStateManager()->onDeleteQueryObject(this);
 }
 
-gl::Error Query11::begin()
+gl::Error Query11::begin(const gl::Context *context)
 {
     mResultSum = 0;
     mRenderer->getStateManager()->onBeginQuery(this);
     return resume();
 }
 
-gl::Error Query11::end()
+gl::Error Query11::end(const gl::Context *context)
 {
     return pause();
 }
 
-gl::Error Query11::queryCounter()
+gl::Error Query11::queryCounter(const gl::Context *context)
 {
     // This doesn't do anything for D3D11 as we don't support timestamps
     ASSERT(getType() == gl::QueryType::Timestamp);
@@ -100,27 +100,27 @@ gl::Error Query11::getResultBase(T *params)
     return gl::NoError();
 }
 
-gl::Error Query11::getResult(GLint *params)
+gl::Error Query11::getResult(const gl::Context *context, GLint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query11::getResult(GLuint *params)
+gl::Error Query11::getResult(const gl::Context *context, GLuint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query11::getResult(GLint64 *params)
+gl::Error Query11::getResult(const gl::Context *context, GLint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query11::getResult(GLuint64 *params)
+gl::Error Query11::getResult(const gl::Context *context, GLuint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query11::isResultAvailable(bool *available)
+gl::Error Query11::isResultAvailable(const gl::Context *context, bool *available)
 {
     ANGLE_TRY(flush(false));
 

src/libANGLE/renderer/d3d/d3d11/Query11.h

@@ -24,14 +24,14 @@ class Query11 : public QueryImpl
     Query11(Renderer11 *renderer, gl::QueryType type);
     ~Query11() override;
 
-    gl::Error begin() override;
-    gl::Error end() override;
-    gl::Error queryCounter() override;
-    gl::Error getResult(GLint *params) override;
-    gl::Error getResult(GLuint *params) override;
-    gl::Error getResult(GLint64 *params) override;
-    gl::Error getResult(GLuint64 *params) override;
-    gl::Error isResultAvailable(bool *available) override;
+    gl::Error begin(const gl::Context *context) override;
+    gl::Error end(const gl::Context *context) override;
+    gl::Error queryCounter(const gl::Context *context) override;
+    gl::Error getResult(const gl::Context *context, GLint *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint *params) override;
+    gl::Error getResult(const gl::Context *context, GLint64 *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint64 *params) override;
+    gl::Error isResultAvailable(const gl::Context *context, bool *available) override;
 
     gl::Error pause();
     gl::Error resume();

src/libANGLE/renderer/d3d/d3d9/Query9.cpp

@@ -29,7 +29,7 @@ Query9::~Query9()
     SafeRelease(mQuery);
 }
 
-gl::Error Query9::begin()
+gl::Error Query9::begin(const gl::Context *context)
 {
     D3DQUERYTYPE d3dQueryType = gl_d3d9::ConvertQueryType(getType());
     if (mQuery == nullptr)
@@ -54,7 +54,7 @@ gl::Error Query9::begin()
     return gl::NoError();
 }
 
-gl::Error Query9::end()
+gl::Error Query9::end(const gl::Context *context)
 {
     ASSERT(mQuery);
 
@@ -71,7 +71,7 @@ gl::Error Query9::end()
     return gl::NoError();
 }
 
-gl::Error Query9::queryCounter()
+gl::Error Query9::queryCounter(const gl::Context *context)
 {
     UNIMPLEMENTED();
     return gl::InternalError() << "Unimplemented";
@@ -99,27 +99,27 @@ gl::Error Query9::getResultBase(T *params)
     return gl::NoError();
 }
 
-gl::Error Query9::getResult(GLint *params)
+gl::Error Query9::getResult(const gl::Context *context, GLint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query9::getResult(GLuint *params)
+gl::Error Query9::getResult(const gl::Context *context, GLuint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query9::getResult(GLint64 *params)
+gl::Error Query9::getResult(const gl::Context *context, GLint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query9::getResult(GLuint64 *params)
+gl::Error Query9::getResult(const gl::Context *context, GLuint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error Query9::isResultAvailable(bool *available)
+gl::Error Query9::isResultAvailable(const gl::Context *context, bool *available)
 {
     gl::Error error = testQuery();
     if (error.isError())

src/libANGLE/renderer/d3d/d3d9/Query9.h

@@ -21,14 +21,14 @@ class Query9 : public QueryImpl
     Query9(Renderer9 *renderer, gl::QueryType type);
     ~Query9() override;
 
-    gl::Error begin() override;
-    gl::Error end() override;
-    gl::Error queryCounter() override;
-    gl::Error getResult(GLint *params) override;
-    gl::Error getResult(GLuint *params) override;
-    gl::Error getResult(GLint64 *params) override;
-    gl::Error getResult(GLuint64 *params) override;
-    gl::Error isResultAvailable(bool *available) override;
+    gl::Error begin(const gl::Context *context) override;
+    gl::Error end(const gl::Context *context) override;
+    gl::Error queryCounter(const gl::Context *context) override;
+    gl::Error getResult(const gl::Context *context, GLint *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint *params) override;
+    gl::Error getResult(const gl::Context *context, GLint64 *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint64 *params) override;
+    gl::Error isResultAvailable(const gl::Context *context, bool *available) override;
 
   private:
     gl::Error testQuery();

src/libANGLE/renderer/gl/QueryGL.cpp

@@ -85,18 +85,18 @@ StandardQueryGL::~StandardQueryGL()
     }
 }
 
-gl::Error StandardQueryGL::begin()
+gl::Error StandardQueryGL::begin(const gl::Context *context)
 {
     mResultSum = 0;
     return resume();
 }
 
-gl::Error StandardQueryGL::end()
+gl::Error StandardQueryGL::end(const gl::Context *context)
 {
     return pause();
 }
 
-gl::Error StandardQueryGL::queryCounter()
+gl::Error StandardQueryGL::queryCounter(const gl::Context *context)
 {
     ASSERT(mType == gl::QueryType::Timestamp);
 
@@ -127,27 +127,27 @@ gl::Error StandardQueryGL::getResultBase(T *params)
     return gl::NoError();
 }
 
-gl::Error StandardQueryGL::getResult(GLint *params)
+gl::Error StandardQueryGL::getResult(const gl::Context *context, GLint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error StandardQueryGL::getResult(GLuint *params)
+gl::Error StandardQueryGL::getResult(const gl::Context *context, GLuint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error StandardQueryGL::getResult(GLint64 *params)
+gl::Error StandardQueryGL::getResult(const gl::Context *context, GLint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error StandardQueryGL::getResult(GLuint64 *params)
+gl::Error StandardQueryGL::getResult(const gl::Context *context, GLuint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error StandardQueryGL::isResultAvailable(bool *available)
+gl::Error StandardQueryGL::isResultAvailable(const gl::Context *context, bool *available)
 {
     ASSERT(mActiveQuery == 0);
 
@@ -339,12 +339,12 @@ bool SyncQueryGL::IsSupported(const FunctionsGL *functions)
     return nativegl::SupportsFenceSync(functions) || nativegl::SupportsOcclusionQueries(functions);
 }
 
-gl::Error SyncQueryGL::begin()
+gl::Error SyncQueryGL::begin(const gl::Context *context)
 {
     return gl::NoError();
 }
 
-gl::Error SyncQueryGL::end()
+gl::Error SyncQueryGL::end(const gl::Context *context)
 {
     if (nativegl::SupportsFenceSync(mFunctions))
     {
@@ -363,33 +363,33 @@ gl::Error SyncQueryGL::end()
     return gl::NoError();
 }
 
-gl::Error SyncQueryGL::queryCounter()
+gl::Error SyncQueryGL::queryCounter(const gl::Context *context)
 {
     UNREACHABLE();
     return gl::NoError();
 }
 
-gl::Error SyncQueryGL::getResult(GLint *params)
+gl::Error SyncQueryGL::getResult(const gl::Context *context, GLint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error SyncQueryGL::getResult(GLuint *params)
+gl::Error SyncQueryGL::getResult(const gl::Context *context, GLuint *params)
 {
     return getResultBase(params);
 }
 
-gl::Error SyncQueryGL::getResult(GLint64 *params)
+gl::Error SyncQueryGL::getResult(const gl::Context *context, GLint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error SyncQueryGL::getResult(GLuint64 *params)
+gl::Error SyncQueryGL::getResult(const gl::Context *context, GLuint64 *params)
 {
     return getResultBase(params);
 }
 
-gl::Error SyncQueryGL::isResultAvailable(bool *available)
+gl::Error SyncQueryGL::isResultAvailable(const gl::Context *context, bool *available)
 {
     ANGLE_TRY(flush(false));
     *available = mFinished;

src/libANGLE/renderer/gl/QueryGL.h

@@ -41,14 +41,14 @@ class StandardQueryGL : public QueryGL
     StandardQueryGL(gl::QueryType type, const FunctionsGL *functions, StateManagerGL *stateManager);
     ~StandardQueryGL() override;
 
-    gl::Error begin() override;
-    gl::Error end() override;
-    gl::Error queryCounter() override;
-    gl::Error getResult(GLint *params) override;
-    gl::Error getResult(GLuint *params) override;
-    gl::Error getResult(GLint64 *params) override;
-    gl::Error getResult(GLuint64 *params) override;
-    gl::Error isResultAvailable(bool *available) override;
+    gl::Error begin(const gl::Context *context) override;
+    gl::Error end(const gl::Context *context) override;
+    gl::Error queryCounter(const gl::Context *context) override;
+    gl::Error getResult(const gl::Context *context, GLint *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint *params) override;
+    gl::Error getResult(const gl::Context *context, GLint64 *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint64 *params) override;
+    gl::Error isResultAvailable(const gl::Context *context, bool *available) override;
 
     gl::Error pause() override;
     gl::Error resume() override;
@@ -78,14 +78,14 @@ class SyncQueryGL : public QueryGL
 
     static bool IsSupported(const FunctionsGL *functions);
 
-    gl::Error begin() override;
-    gl::Error end() override;
-    gl::Error queryCounter() override;
-    gl::Error getResult(GLint *params) override;
-    gl::Error getResult(GLuint *params) override;
-    gl::Error getResult(GLint64 *params) override;
-    gl::Error getResult(GLuint64 *params) override;
-    gl::Error isResultAvailable(bool *available) override;
+    gl::Error begin(const gl::Context *context) override;
+    gl::Error end(const gl::Context *context) override;
+    gl::Error queryCounter(const gl::Context *context) override;
+    gl::Error getResult(const gl::Context *context, GLint *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint *params) override;
+    gl::Error getResult(const gl::Context *context, GLint64 *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint64 *params) override;
+    gl::Error isResultAvailable(const gl::Context *context, bool *available) override;
 
     gl::Error pause() override;
     gl::Error resume() override;

src/libANGLE/renderer/null/QueryNULL.cpp

@@ -22,46 +22,46 @@ QueryNULL::~QueryNULL()
 {
 }
 
-gl::Error QueryNULL::begin()
+gl::Error QueryNULL::begin(const gl::Context *context)
 {
     return gl::NoError();
 }
 
-gl::Error QueryNULL::end()
+gl::Error QueryNULL::end(const gl::Context *context)
 {
     return gl::NoError();
 }
 
-gl::Error QueryNULL::queryCounter()
+gl::Error QueryNULL::queryCounter(const gl::Context *context)
 {
     return gl::NoError();
 }
 
-gl::Error QueryNULL::getResult(GLint *params)
+gl::Error QueryNULL::getResult(const gl::Context *context, GLint *params)
 {
     *params = 0;
     return gl::NoError();
 }
 
-gl::Error QueryNULL::getResult(GLuint *params)
+gl::Error QueryNULL::getResult(const gl::Context *context, GLuint *params)
 {
     *params = 0;
     return gl::NoError();
 }
 
-gl::Error QueryNULL::getResult(GLint64 *params)
+gl::Error QueryNULL::getResult(const gl::Context *context, GLint64 *params)
 {
     *params = 0;
     return gl::NoError();
 }
 
-gl::Error QueryNULL::getResult(GLuint64 *params)
+gl::Error QueryNULL::getResult(const gl::Context *context, GLuint64 *params)
 {
     *params = 0;
     return gl::NoError();
 }
 
-gl::Error QueryNULL::isResultAvailable(bool *available)
+gl::Error QueryNULL::isResultAvailable(const gl::Context *context, bool *available)
 {
     *available = true;
     return gl::NoError();

src/libANGLE/renderer/null/QueryNULL.h

@@ -21,14 +21,14 @@ class QueryNULL : public QueryImpl
     QueryNULL(gl::QueryType type);
     ~QueryNULL() override;
 
-    gl::Error begin() override;
-    gl::Error end() override;
-    gl::Error queryCounter() override;
-    gl::Error getResult(GLint *params) override;
-    gl::Error getResult(GLuint *params) override;
-    gl::Error getResult(GLint64 *params) override;
-    gl::Error getResult(GLuint64 *params) override;
-    gl::Error isResultAvailable(bool *available) override;
+    gl::Error begin(const gl::Context *context) override;
+    gl::Error end(const gl::Context *context) override;
+    gl::Error queryCounter(const gl::Context *context) override;
+    gl::Error getResult(const gl::Context *context, GLint *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint *params) override;
+    gl::Error getResult(const gl::Context *context, GLint64 *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint64 *params) override;
+    gl::Error isResultAvailable(const gl::Context *context, bool *available) override;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/QueryVk.cpp

@@ -22,49 +22,49 @@ QueryVk::~QueryVk()
 {
 }
 
-gl::Error QueryVk::begin()
+gl::Error QueryVk::begin(const gl::Context *context)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::end()
+gl::Error QueryVk::end(const gl::Context *context)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::queryCounter()
+gl::Error QueryVk::queryCounter(const gl::Context *context)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::getResult(GLint *params)
+gl::Error QueryVk::getResult(const gl::Context *context, GLint *params)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::getResult(GLuint *params)
+gl::Error QueryVk::getResult(const gl::Context *context, GLuint *params)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::getResult(GLint64 *params)
+gl::Error QueryVk::getResult(const gl::Context *context, GLint64 *params)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::getResult(GLuint64 *params)
+gl::Error QueryVk::getResult(const gl::Context *context, GLuint64 *params)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error QueryVk::isResultAvailable(bool *available)
+gl::Error QueryVk::isResultAvailable(const gl::Context *context, bool *available)
 {
     UNIMPLEMENTED();
     return gl::InternalError();

src/libANGLE/renderer/vulkan/QueryVk.h

@@ -21,14 +21,14 @@ class QueryVk : public QueryImpl
     QueryVk(gl::QueryType type);
     ~QueryVk() override;
 
-    gl::Error begin() override;
-    gl::Error end() override;
-    gl::Error queryCounter() override;
-    gl::Error getResult(GLint *params) override;
-    gl::Error getResult(GLuint *params) override;
-    gl::Error getResult(GLint64 *params) override;
-    gl::Error getResult(GLuint64 *params) override;
-    gl::Error isResultAvailable(bool *available) override;
+    gl::Error begin(const gl::Context *context) override;
+    gl::Error end(const gl::Context *context) override;
+    gl::Error queryCounter(const gl::Context *context) override;
+    gl::Error getResult(const gl::Context *context, GLint *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint *params) override;
+    gl::Error getResult(const gl::Context *context, GLint64 *params) override;
+    gl::Error getResult(const gl::Context *context, GLuint64 *params) override;
+    gl::Error isResultAvailable(const gl::Context *context, bool *available) override;
 };
 
 }  // namespace rx