gfx/skia/trunk/src/gpu/gl/GrGLNoOpInterface.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Sat, 03 Jan 2015 20:18:00 +0100
branch
TOR_BUG_3246
changeset 7
129ffea94266
permissions
-rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

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

mercurial