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