src/third_party/skia/src/gpu/gl/GrGLNoOpInterface.cpp

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "GrGLNoOpInterface.h"
   9 #include "SkString.h"
  10 #include "SkThread.h"
  11
  12 // the OpenGLES 2.0 spec says this must be >= 128
  13 static const GrGLint kDefaultMaxVertexUniformVectors = 128;
  14
  15 // the OpenGLES 2.0 spec says this must be >=16
  16 static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
  17
  18 // the OpenGLES 2.0 spec says this must be >= 8
  19 static const GrGLint kDefaultMaxVertexAttribs = 8;
  20
  21 // the OpenGLES 2.0 spec says this must be >= 8
  22 static const GrGLint kDefaultMaxVaryingVectors = 8;
  23
  24 static const char* kExtensions[] = {
  25     "GL_ARB_framebuffer_object",
  26     "GL_ARB_blend_func_extended",
  27     "GL_ARB_timer_query",
  28     "GL_ARB_draw_buffers",
  29     "GL_ARB_occlusion_query",
  30     "GL_EXT_blend_color",
  31     "GL_EXT_stencil_wrap"
  32 };
  33
  34 namespace {
  35 const GrGLubyte* combined_extensions_string() {
  36     static SkString gExtString;
  37     static SkMutex gMutex;
  38     gMutex.acquire();
  39     if (0 == gExtString.size()) {
  40         for (size_t i = 0; i < SK_ARRAY_COUNT(kExtensions) - 1; ++i) {
  41             gExtString.append(kExtensions[i]);
  42             gExtString.append(" ");
  43         }
  44         gExtString.append(kExtensions[SK_ARRAY_COUNT(kExtensions) - 1]);
  45     }
  46     gMutex.release();
  47     return (const GrGLubyte*) gExtString.c_str();
  48 }
  49 }
  50
  51 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
  52                                               GrGLclampf green,
  53                                               GrGLclampf blue,
  54                                               GrGLclampf alpha) {
  55 }
  56
  57 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
  58                                                         GrGLuint colorNumber,
  59                                                         const GrGLchar* name) {
  60 }
  61
  62 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendFunc(GrGLenum sfactor,
  63                                               GrGLenum dfactor) {
  64 }
  65
  66 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBufferSubData(GrGLenum target,
  67                                                  GrGLintptr offset,
  68                                                  GrGLsizeiptr size,
  69                                                  const GrGLvoid* data) {
  70 }
  71
  72 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClear(GrGLbitfield mask) {
  73 }
  74
  75 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
  76                                               GrGLclampf green,
  77                                               GrGLclampf blue,
  78                                               GrGLclampf alpha) {
  79 }
  80
  81 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s) {
  82 }
  83
  84 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
  85                                              GrGLboolean green,
  86                                              GrGLboolean blue,
  87                                              GrGLboolean alpha) {
  88 }
  89
  90 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader) {
  91 }
  92
  93 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
  94                                                         GrGLint level,
  95                                                         GrGLenum internalformat,
  96                                                         GrGLsizei width,
  97                                                         GrGLsizei height,
  98                                                         GrGLint border,
  99                                                         GrGLsizei imageSize,
 100                                                         const GrGLvoid* data) {
 101 }
 102
 103 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexSubImage2D(GrGLenum target,
 104                                                            GrGLint level,
 105                                                            GrGLint xoffset,
 106                                                            GrGLint yoffset,
 107                                                            GrGLsizei width,
 108                                                            GrGLsizei height,
 109                                                            GrGLenum format,
 110                                                            GrGLsizei imageSize,
 111                                                            const GrGLvoid* data) {
 112 }
 113
 114 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCopyTexSubImage2D(GrGLenum target,
 115                                                      GrGLint level,
 116                                                      GrGLint xoffset,
 117                                                      GrGLint yoffset,
 118                                                      GrGLint x,
 119                                                      GrGLint y,
 120                                                      GrGLsizei width,
 121                                                      GrGLsizei height) {
 122 }
 123
 124 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCullFace(GrGLenum mode) {
 125 }
 126
 127 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDepthMask(GrGLboolean flag) {
 128 }
 129
 130 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisable(GrGLenum cap) {
 131 }
 132
 133 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisableVertexAttribArray(GrGLuint index) {
 134 }
 135
 136 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArrays(GrGLenum mode,
 137                                               GrGLint first,
 138                                               GrGLsizei count) {
 139 }
 140
 141 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffer(GrGLenum mode) {
 142 }
 143
 144 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffers(GrGLsizei n,
 145                                                const GrGLenum* bufs) {
 146 }
 147
 148 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElements(GrGLenum mode,
 149                                                 GrGLsizei count,
 150                                                 GrGLenum type,
 151                                                 const GrGLvoid* indices) {
 152 }
 153
 154 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnable(GrGLenum cap) {
 155 }
 156
 157 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnableVertexAttribArray(GrGLuint index) {
 158 }
 159
 160 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEndQuery(GrGLenum target) {
 161 }
 162
 163 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFinish() {
 164 }
 165
 166 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush() {
 167 }
 168
 169 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode) {
 170 }
 171
 172 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width) {
 173 }
 174
 175 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program) {
 176 }
 177
 178 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadf(GrGLenum, const GrGLfloat*) {
 179 }
 180
 181 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadIdentity(GrGLenum) {
 182 }
 183
 184 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target) {
 185 }
 186
 187 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src) {
 188 }
 189
 190 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
 191                                            GrGLint y,
 192                                            GrGLsizei width,
 193                                            GrGLsizei height) {
 194 }
 195
 196 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
 197                                                 GrGLsizei count,
 198 #if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE
 199                                                 const char* const * str,
 200 #else
 201                                                 const char** str,
 202 #endif
 203                                                 const GrGLint* length) {
 204 }
 205
 206 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {
 207 }
 208
 209 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFuncSeparate(GrGLenum face,
 210                                                        GrGLenum func,
 211                                                        GrGLint ref,
 212                                                        GrGLuint mask) {
 213 }
 214
 215 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMask(GrGLuint mask) {
 216 }
 217
 218 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMaskSeparate(GrGLenum face, GrGLuint mask) {
 219 }
 220
 221 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass) {
 222 }
 223
 224 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face,
 225                                                      GrGLenum fail,
 226                                                      GrGLenum zfail,
 227                                                      GrGLenum zpass) {
 228 }
 229
 230 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target,
 231                                               GrGLint level,
 232                                               GrGLint internalformat,
 233                                               GrGLsizei width,
 234                                               GrGLsizei height,
 235                                               GrGLint border,
 236                                               GrGLenum format,
 237                                               GrGLenum type,
 238                                               const GrGLvoid* pixels) {
 239 }
 240
 241 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteri(GrGLenum target,
 242                                                  GrGLenum pname,
 243                                                  GrGLint param) {
 244 }
 245
 246 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteriv(GrGLenum target,
 247                                                   GrGLenum pname,
 248                                                   const GrGLint* params) {
 249 }
 250
 251 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target,
 252                                                 GrGLsizei levels,
 253                                                 GrGLenum internalformat,
 254                                                 GrGLsizei width,
 255                                                 GrGLsizei height) {
 256 }
 257
 258 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target,
 259                                                       GrGLsizei numAttachments,
 260                                                       const GrGLenum* attachments) {
 261 }
 262
 263 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexSubImage2D(GrGLenum target,
 264                                                  GrGLint level,
 265                                                  GrGLint xoffset,
 266                                                  GrGLint yoffset,
 267                                                  GrGLsizei width,
 268                                                  GrGLsizei height,
 269                                                  GrGLenum format,
 270                                                  GrGLenum type,
 271                                                  const GrGLvoid* pixels) {
 272 }
 273
 274 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1f(GrGLint location, GrGLfloat v0) {
 275 }
 276
 277 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1i(GrGLint location, GrGLint v0) {
 278 }
 279
 280 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1fv(GrGLint location,
 281                                               GrGLsizei count,
 282                                               const GrGLfloat* v) {
 283 }
 284
 285 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1iv(GrGLint location,
 286                                               GrGLsizei count,
 287                                               const GrGLint* v) {
 288 }
 289
 290 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2f(GrGLint location, GrGLfloat v0, GrGLfloat v1) {
 291 }
 292
 293 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2i(GrGLint location, GrGLint v0, GrGLint v1) {
 294 }
 295
 296 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2fv(GrGLint location,
 297                                               GrGLsizei count,
 298                                               const GrGLfloat* v) {
 299 }
 300
 301 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2iv(GrGLint location,
 302                                               GrGLsizei count,
 303                                               const GrGLint* v) {
 304 }
 305
 306 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3f(GrGLint location,
 307                                               GrGLfloat v0,
 308                                               GrGLfloat v1,
 309                                               GrGLfloat v2) {
 310 }
 311
 312 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3i(GrGLint location,
 313                                               GrGLint v0,
 314                                               GrGLint v1,
 315                                               GrGLint v2) {
 316 }
 317
 318 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3fv(GrGLint location,
 319                                               GrGLsizei count,
 320                                               const GrGLfloat* v) {
 321 }
 322
 323 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3iv(GrGLint location,
 324                                               GrGLsizei count,
 325                                               const GrGLint* v) {
 326 }
 327
 328 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4f(GrGLint location,
 329                                               GrGLfloat v0,
 330                                               GrGLfloat v1,
 331                                               GrGLfloat v2,
 332                                               GrGLfloat v3) {
 333 }
 334
 335 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4i(GrGLint location,
 336                                               GrGLint v0,
 337                                               GrGLint v1,
 338                                               GrGLint v2,
 339                                               GrGLint v3) {
 340 }
 341
 342 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4fv(GrGLint location,
 343                                               GrGLsizei count,
 344                                               const GrGLfloat* v) {
 345 }
 346
 347 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4iv(GrGLint location,
 348                                               GrGLsizei count,
 349                                               const GrGLint* v) {
 350 }
 351
 352 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix2fv(GrGLint location,
 353                                                     GrGLsizei count,
 354                                                     GrGLboolean transpose,
 355                                                     const GrGLfloat* value) {
 356 }
 357
 358 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix3fv(GrGLint location,
 359                                                     GrGLsizei count,
 360                                                     GrGLboolean transpose,
 361                                                     const GrGLfloat* value) {
 362 }
 363
 364 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix4fv(GrGLint location,
 365                                                     GrGLsizei count,
 366                                                     GrGLboolean transpose,
 367                                                     const GrGLfloat* value) {
 368 }
 369
 370  GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib1f(GrGLuint indx, const GrGLfloat value) {
 371 }
 372
 373  GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib2fv(GrGLuint indx, const GrGLfloat* values) {
 374 }
 375
 376  GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib3fv(GrGLuint indx, const GrGLfloat* values) {
 377 }
 378
 379  GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib4fv(GrGLuint indx, const GrGLfloat* values) {
 380 }
 381
 382 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
 383                                                        GrGLint size,
 384                                                        GrGLenum type,
 385                                                        GrGLboolean normalized,
 386                                                        GrGLsizei stride,
 387                                                        const GrGLvoid* ptr) {
 388 }
 389
 390 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
 391                                             GrGLint y,
 392                                             GrGLsizei width,
 393                                             GrGLsizei height) {
 394 }
 395
 396   GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
 397                                                                          GrGLenum attachment,
 398                                                                          GrGLenum pname,
 399                                                                          GrGLint* params) {
 400 }
 401
 402 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
 403                                                               GrGLenum pname,
 404                                                               GrGLint* params) {
 405 }
 406
 407 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
 408                                                        GrGLenum internalformat,
 409                                                        GrGLsizei width,
 410                                                        GrGLsizei height) {
 411 }
 412
 413 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorageMultisample(GrGLenum target,
 414                                                                   GrGLsizei samples,
 415                                                                   GrGLenum internalformat,
 416                                                                   GrGLsizei width,
 417                                                                   GrGLsizei height) {
 418 }
 419
 420 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlitFramebuffer(GrGLint srcX0,
 421                                                    GrGLint srcY0,
 422                                                    GrGLint srcX1,
 423                                                    GrGLint srcY1,
 424                                                    GrGLint dstX0,
 425                                                    GrGLint dstY0,
 426                                                    GrGLint dstX1,
 427                                                    GrGLint dstY1,
 428                                                    GrGLbitfield mask,
 429                                                    GrGLenum filter) {
 430 }
 431
 432 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLResolveMultisampleFramebuffer() {
 433 }
 434
 435 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocationIndexed(GrGLuint program,
 436                                                                GrGLuint colorNumber,
 437                                                                GrGLuint index,
 438                                                                const GrGLchar * name) {
 439 }
 440
 441 GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target) {
 442
 443     GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
 444
 445     return GR_GL_FRAMEBUFFER_COMPLETE;
 446 }
 447
 448 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGenIds(GrGLsizei n, GrGLuint* ids) {
 449     static int gCurrID = 1;
 450     for (int i = 0; i < n; ++i) {
 451         ids[i] = ++gCurrID;
 452    }
 453 }
 454
 455 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDeleteIds(GrGLsizei n, const GrGLuint* ids) {
 456 }
 457
 458 GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError() {
 459     return GR_GL_NO_ERROR;
 460 }
 461
 462 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params) {
 463     // TODO: remove from Ganesh the #defines for gets we don't use.
 464     // We would like to minimize gets overall due to performance issues
 465     switch (pname) {
 466         case GR_GL_CONTEXT_PROFILE_MASK:
 467             *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
 468             break;
 469         case GR_GL_STENCIL_BITS:
 470             *params = 8;
 471             break;
 472         case GR_GL_SAMPLES:
 473             *params = 1;
 474             break;
 475         case GR_GL_FRAMEBUFFER_BINDING:
 476             *params = 0;
 477             break;
 478         case GR_GL_VIEWPORT:
 479             params[0] = 0;
 480             params[1] = 0;
 481             params[2] = 800;
 482             params[3] = 600;
 483             break;
 484         case GR_GL_MAX_TEXTURE_IMAGE_UNITS:
 485             *params = 8;
 486             break;
 487         case GR_GL_MAX_TEXTURE_COORDS:
 488             *params = 8;
 489             break;
 490         case GR_GL_MAX_VERTEX_UNIFORM_VECTORS:
 491             *params = kDefaultMaxVertexUniformVectors;
 492             break;
 493         case GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
 494             *params = kDefaultMaxFragmentUniformVectors;
 495             break;
 496         case GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
 497             *params = 16 * 4;
 498             break;
 499         case GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
 500             *params = 0;
 501             break;
 502         case GR_GL_COMPRESSED_TEXTURE_FORMATS:
 503             break;
 504         case GR_GL_MAX_TEXTURE_SIZE:
 505             *params = 8192;
 506             break;
 507         case GR_GL_MAX_RENDERBUFFER_SIZE:
 508             *params = 8192;
 509             break;
 510         case GR_GL_MAX_SAMPLES:
 511             *params = 32;
 512             break;
 513         case GR_GL_MAX_VERTEX_ATTRIBS:
 514             *params = kDefaultMaxVertexAttribs;
 515             break;
 516         case GR_GL_MAX_VARYING_VECTORS:
 517             *params = kDefaultMaxVaryingVectors;
 518             break;
 519         case GR_GL_NUM_EXTENSIONS:
 520             *params = SK_ARRAY_COUNT(kExtensions);
 521             break;
 522         default:
 523             SkFAIL("Unexpected pname to GetIntegerv");
 524    }
 525 }
 526
 527 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
 528                                               GrGLsizei bufsize,
 529                                               GrGLsizei* length,
 530                                               char* infolog) {
 531     if (length) {
 532         *length = 0;
 533    }
 534     if (bufsize > 0) {
 535         *infolog = 0;
 536    }
 537 }
 538
 539 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
 540                                                         GrGLenum pname,
 541                                                         GrGLint* params) {
 542     switch (pname) {
 543         case GR_GL_LINK_STATUS:  // fallthru
 544         case GR_GL_COMPILE_STATUS:
 545             *params = GR_GL_TRUE;
 546             break;
 547         case GR_GL_INFO_LOG_LENGTH:
 548             *params = 0;
 549             break;
 550         // we don't expect any other pnames
 551         default:
 552             SkFAIL("Unexpected pname to GetProgramiv");
 553             break;
 554    }
 555 }
 556
 557 namespace {
 558 template <typename T>
 559 void query_result(GrGLenum GLtarget, GrGLenum pname, T *params) {
 560     switch (pname) {
 561         case GR_GL_QUERY_RESULT_AVAILABLE:
 562             *params = GR_GL_TRUE;
 563             break;
 564         case GR_GL_QUERY_RESULT:
 565             *params = 0;
 566             break;
 567         default:
 568             SkFAIL("Unexpected pname passed to GetQueryObject.");
 569             break;
 570    }
 571 }
 572 }
 573
 574 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
 575                                               GrGLenum pname,
 576                                               GrGLint *params) {
 577     switch (pname) {
 578         case GR_GL_CURRENT_QUERY:
 579             *params = 0;
 580             break;
 581         case GR_GL_QUERY_COUNTER_BITS:
 582             *params = 32;
 583             break;
 584         default:
 585             SkFAIL("Unexpected pname passed GetQueryiv.");
 586    }
 587 }
 588
 589 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
 590                                                       GrGLenum pname,
 591                                                       GrGLint64 *params) {
 592     query_result(id, pname, params);
 593 }
 594
 595 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id,
 596                                                     GrGLenum pname,
 597                                                     GrGLint *params) {
 598     query_result(id, pname, params);
 599 }
 600
 601 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectui64v(GrGLuint id,
 602                                                        GrGLenum pname,
 603                                                        GrGLuint64 *params) {
 604     query_result(id, pname, params);
 605 }
 606
 607 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
 608                                                      GrGLenum pname,
 609                                                      GrGLuint *params) {
 610     query_result(id, pname, params);
 611 }
 612
 613 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name) {
 614     switch (name) {
 615         case GR_GL_EXTENSIONS:
 616             return combined_extensions_string();
 617         case GR_GL_VERSION:
 618             return (const GrGLubyte*)"4.0 Debug GL";
 619         case GR_GL_SHADING_LANGUAGE_VERSION:
 620             return (const GrGLubyte*)"4.20.8 Debug GLSL";
 621         case GR_GL_VENDOR:
 622             return (const GrGLubyte*)"Debug Vendor";
 623         case GR_GL_RENDERER:
 624             return (const GrGLubyte*)"The Debug (Non-)Renderer";
 625         default:
 626             SkFAIL("Unexpected name passed to GetString");
 627             return NULL;
 628    }
 629 }
 630
 631 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i) {
 632     switch (name) {
 633         case GR_GL_EXTENSIONS:
 634             if (static_cast<size_t>(i) <= SK_ARRAY_COUNT(kExtensions)) {
 635                 return (const GrGLubyte*) kExtensions[i];
 636             } else {
 637                 return NULL;
 638             }
 639         default:
 640             SkFAIL("Unexpected name passed to GetStringi");
 641             return NULL;
 642     }
 643 }
 644
 645 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
 646                                                           GrGLint level,
 647                                                           GrGLenum pname,
 648                                                           GrGLint* params) {
 649     // we used to use this to query stuff about externally created textures,
 650     // now we just require clients to tell us everything about the texture.
 651     SkFAIL("Should never query texture parameters.");
 652 }
 653
 654 GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name) {
 655     static int gUniLocation = 0;
 656     return ++gUniLocation;
 657 }
 658
 659 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker) {
 660 }
 661 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length  , const char* marker) {
 662 }
 663 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker() {
 664 }