Revert of Separate user and raw stencil settings

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLGpu.h"
@@ skipping 52 matching lines @@
         SkASSERT(!SkScalarIsNaN(SkFloatToScalar(floats[i])));
     }
 }
 #endif
 
 static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
     switch (op) {
         default:
             SkFAIL("Unexpected path fill.");
             /* fallthrough */;
-        case GrStencilOp::kIncClamp:
+        case kIncClamp_StencilOp:
             return GR_GL_COUNT_UP;
-        case GrStencilOp::kInvert:
+        case kInvert_StencilOp:
             return GR_GL_INVERT;
     }
 }
 
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu)
     , fPreallocatedPathCount(0) {
     const GrGLInterface* glInterface = gpu->glInterface();
     fCaps.bindFragmentInputSupport =
         nullptr != glInterface->fFunctions.fBindFragmentInputLocation;
@@ skipping 40 matching lines @@
     this->setProjectionMatrix(*args.fViewMatrix, size, rt->origin());
     gpu->flushScissor(*args.fScissor, rt->getViewport(), rt->origin());
     gpu->flushHWAAState(rt, args.fUseHWAA, true);
     gpu->flushRenderTarget(rt, nullptr);
 
     const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
 
     this->flushPathStencilSettings(*args.fStencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
-    GrGLenum fillMode =
-        gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
-    GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;
+    GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
+        fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (glPath->shouldFill()) {
         GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
     }
     if (glPath->shouldStroke()) {
         GL_CALL(StencilStrokePath(glPath->pathID(), 0xffff, writeMask));
     }
 }
 
 void GrGLPathRendering::onDrawPath(const GrPipeline& pipeline,
                                    const GrPrimitiveProcessor& primProc,
                                    const GrStencilSettings& stencil,
                                    const GrPath* path) {
     if (!this->gpu()->flushGLState(pipeline, primProc)) {
         return;
     }
     const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
 
     this->flushPathStencilSettings(stencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
-    GrGLenum fillMode =
-        gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
-    GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;
+    GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
+        fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (glPath->shouldStroke()) {
         if (glPath->shouldFill()) {
             GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
         }
         GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
                                            GR_GL_BOUNDING_BOX));
     } else {
         GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
                                          GR_GL_BOUNDING_BOX));
@@ skipping 11 matching lines @@
     if (!this->gpu()->flushGLState(pipeline, primProc)) {
         return;
     }
     this->flushPathStencilSettings(stencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
 
     const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);
 
     GrGLenum fillMode =
-        gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
-    GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;
+        gr_stencil_op_to_gl_path_rendering_fill_mode(
+            fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLint writeMask =
+        fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (glPathRange->shouldStroke()) {
         if (glPathRange->shouldFill()) {
             GL_CALL(StencilFillPathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, gXformType2GLType[transformType],
                             transformValues));
         }
         GL_CALL(StencilThenCoverStrokePathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
@@ skipping 107 matching lines @@
 
 void GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
     GL_CALL(DeletePaths(path, range));
 }
 
 void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stencilSettings) {
     if (fHWPathStencilSettings != stencilSettings) {
         SkASSERT(stencilSettings.isValid());
         // Just the func, ref, and mask is set here. The op and write mask are params to the call
         // that draws the path to the SB (glStencilFillPath)
-        uint16_t ref = stencilSettings.front().fRef;
-        GrStencilTest test = stencilSettings.front().fTest;
-        uint16_t testMask = stencilSettings.front().fTestMask;
+        const GrStencilSettings::Face kFront_Face = GrStencilSettings::kFront_Face;
+        GrStencilFunc func = stencilSettings.func(kFront_Face);
+        uint16_t funcRef = stencilSettings.funcRef(kFront_Face);
+        uint16_t funcMask = stencilSettings.funcMask(kFront_Face);
 
         if (!fHWPathStencilSettings.isValid() ||
-            ref != fHWPathStencilSettings.front().fRef ||
-            test != fHWPathStencilSettings.front().fTest ||
-            testMask != fHWPathStencilSettings.front().fTestMask) {
-            GL_CALL(PathStencilFunc(GrToGLStencilFunc(test), ref, testMask));
+            func != fHWPathStencilSettings.func(kFront_Face) ||
+            funcRef != fHWPathStencilSettings.funcRef(kFront_Face) ||
+            funcMask != fHWPathStencilSettings.funcMask(kFront_Face)) {
+            GL_CALL(PathStencilFunc(GrToGLStencilFunc(func), funcRef, funcMask));
         }
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }