Enable NV_path_rendering in the Null GL.

src/gpu/gl/GrGLCreateNullInterface.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "gl/GrGLInterface.h"
 #include "GrGLTestInterface.h"
@@ skipping 94 matching lines @@
     static const intptr_t kFreeListEnd = -1;
     // Index of the first entry of fBuffers in the free list. Free slots in fBuffers are indices to
     // the next free slot. The last free slot has a value of kFreeListEnd.
     intptr_t                fFreeListHead;
     SkTDArray<BufferObj*>   fBuffers;
 };
 
 /** Null interface implementation */
 class NullInterface : public GrGLTestInterface {
 public:
-    NullInterface()
+    NullInterface(bool enableNVPR)
         : fCurrArrayBuffer(0)
         , fCurrElementArrayBuffer(0)
         , fCurrPixelPackBuffer(0)
         , fCurrPixelUnpackBuffer(0)
         , fCurrProgramID(0)
         , fCurrShaderID(0)
         , fCurrGenericID(0)
-        , fCurrUniformLocation(0) {
+        , fCurrUniformLocation(0)
+        , fCurrPathID(0) {
+        fExtensions.push_back("GL_ARB_framebuffer_object");
+        fExtensions.push_back("GL_ARB_blend_func_extended");
+        fExtensions.push_back("GL_ARB_timer_query");
+        fExtensions.push_back("GL_ARB_draw_buffers");
+        fExtensions.push_back("GL_ARB_occlusion_query");
+        fExtensions.push_back("GL_EXT_stencil_wrap");
+        if (enableNVPR) {
+            fExtensions.push_back("GL_NV_path_rendering");
+            fExtensions.push_back("GL_ARB_program_interface_query");
+        }
+        fExtensions.push_back(nullptr);
+
         this->init(kGL_GrGLStandard);
     }
 
     GrGLenum checkFramebufferStatus(GrGLenum target) override {
         return GR_GL_FRAMEBUFFER_COMPLETE;
     }
 
     GrGLvoid genBuffers(GrGLsizei n, GrGLuint* ids) override {
         for (int i = 0; i < n; ++i) {
             BufferObj* buffer = fBufferManager.create();
@@ skipping 152 matching lines @@
                 *params = 32;
                 break;
             case GR_GL_MAX_VERTEX_ATTRIBS:
                 *params = kDefaultMaxVertexAttribs;
                 break;
             case GR_GL_MAX_VARYING_VECTORS:
                 *params = kDefaultMaxVaryingVectors;
                 break;
             case GR_GL_NUM_EXTENSIONS: {
                 GrGLint i = 0;
-                while (kExtensions[i++]);
+                while (fExtensions[i++]);
                 *params = i;
                 break;
             }
             default:
                 SkFAIL("Unexpected pname to GetIntegerv");
         }
     }
 
     GrGLvoid getProgramiv(GrGLuint program, GrGLenum pname, GrGLint* params) override {
         this->getShaderOrProgramiv(program, pname, params);
@@ skipping 63 matching lines @@
                 return nullptr;
         }
     }
 
     const GrGLubyte* getStringi(GrGLenum name, GrGLuint i) override {
         switch (name) {
             case GR_GL_EXTENSIONS: {
                 GrGLint count;
                 this->getIntegerv(GR_GL_NUM_EXTENSIONS, &count);
                 if ((GrGLint)i <= count) {
-                    return (const GrGLubyte*) kExtensions[i];
+                    return (const GrGLubyte*) fExtensions[i];
                 } else {
                     return nullptr;
                 }
             }
             default:
                 SkFAIL("Unexpected name passed to GetStringi");
                 return nullptr;
         }
     }
 
@@ skipping 109 matching lines @@
                         *params = GR_GL_TRUE;
                     }
                 }
                 break; }
             default:
                 SkFAIL("Unexpected pname to GetBufferParamateriv");
                 break;
         }
     };
 
+    // NV_path_rendering
+    GrGLuint genPaths(GrGLsizei range) override {
+        return ++fCurrPathID;
+    }
+
+
 private:
-    BufferManager   fBufferManager;
-    GrGLuint        fCurrArrayBuffer;
-    GrGLuint        fCurrElementArrayBuffer;
-    GrGLuint        fCurrPixelPackBuffer;
-    GrGLuint        fCurrPixelUnpackBuffer;
-    GrGLuint        fCurrProgramID;
-    GrGLuint        fCurrShaderID;
-    GrGLuint        fCurrGenericID;
-    GrGLuint        fCurrUniformLocation;
+    BufferManager          fBufferManager;
+    GrGLuint               fCurrArrayBuffer;
+    GrGLuint               fCurrElementArrayBuffer;
+    GrGLuint               fCurrPixelPackBuffer;
+    GrGLuint               fCurrPixelUnpackBuffer;
+    GrGLuint               fCurrProgramID;
+    GrGLuint               fCurrShaderID;
+    GrGLuint               fCurrGenericID;
+    GrGLuint               fCurrUniformLocation;
+    GrGLuint               fCurrPathID;
+    SkTArray<const char*>  fExtensions;
 
     // the OpenGLES 2.0 spec says this must be >= 128
     static const GrGLint kDefaultMaxVertexUniformVectors = 128;
 
     // the OpenGLES 2.0 spec says this must be >=16
     static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
 
     // the OpenGLES 2.0 spec says this must be >= 8
     static const GrGLint kDefaultMaxVertexAttribs = 8;
 
     // the OpenGLES 2.0 spec says this must be >= 8
     static const GrGLint kDefaultMaxVaryingVectors = 8;
 
-    static const char* kExtensions[];
-
-    static const GrGLubyte* CombinedExtensionString() {
+    const GrGLubyte* CombinedExtensionString() {
         static SkString gExtString;
         static SkMutex gMutex;
         gMutex.acquire();
         if (0 == gExtString.size()) {
             int i = 0;
-            while (kExtensions[i]) {
+            while (fExtensions[i]) {
                 if (i > 0) {
                     gExtString.append(" ");
                 }
-                gExtString.append(kExtensions[i]);
+                gExtString.append(fExtensions[i]);
                 ++i;
             }
         }
         gMutex.release();
         return (const GrGLubyte*) gExtString.c_str();
     }
 
     GrGLvoid genGenericIds(GrGLsizei n, GrGLuint* ids) {
         for (int i = 0; i < n; ++i) {
             ids[i] = ++fCurrGenericID;
@@ skipping 37 matching lines @@
                 break;
             default:
                 SkFAIL("Unexpected pname passed to GetQueryObject.");
                 break;
         }
     }
 
     typedef GrGLTestInterface INHERITED;
 };
 
-const char* NullInterface::kExtensions[] = {
-    "GL_ARB_framebuffer_object",
-    "GL_ARB_blend_func_extended",
-    "GL_ARB_timer_query",
-    "GL_ARB_draw_buffers",
-    "GL_ARB_occlusion_query",
-    "GL_EXT_stencil_wrap",
-    nullptr, // signifies the end of the array.
-};
-
 }  // anonymous namespace
 
-const GrGLInterface* GrGLCreateNullInterface() { return new NullInterface; }
+const GrGLInterface* GrGLCreateNullInterface(bool enableNVPR) { return new NullInterface(enableNVPR); }