Args structs to GrPathRenderer functions

src/gpu/GrClipMaskManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrAAConvexPathRenderer.h"
 #include "GrAAHairLinePathRenderer.h"
@@ skipping 414 matching lines @@
             if (NULL == pr) {
                 GrPathRendererChain::DrawType type;
                 type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
                 pr = this->getContext()->getPathRenderer(fClipTarget, pipelineBuilder, viewMatrix,
                                                          path, stroke, false, type);
             }
             if (NULL == pr) {
                 return false;
             }
-
-            pr->drawPath(fClipTarget, pipelineBuilder, color, viewMatrix, path, stroke,
-                         element->isAA());
+            GrPathRenderer::DrawPathArgs args;
+            args.fTarget = fClipTarget;
+            args.fResourceProvider = this->getContext()->resourceProvider();
+            args.fPipelineBuilder = pipelineBuilder;
+            args.fColor = color;
+            args.fViewMatrix = &viewMatrix;
+            args.fPath = &path;
+            args.fStroke = &stroke;
+            args.fAntiAlias = element->isAA();
+            pr->drawPath(args);
             break;
         }
     }
     return true;
 }
 
 bool GrClipMaskManager::canStencilAndDrawElement(GrPipelineBuilder* pipelineBuilder,
                                                  GrTexture* target,
                                                  GrPathRenderer** pr,
                                                  const SkClipStack::Element* element) {
@@ skipping 374 matching lines @@
 
                     // We need this AGP until everything is in GrBatch
                     fClipTarget->drawSimpleRect(pipelineBuilder,
                                                 GrColor_WHITE,
                                                 viewMatrix,
                                                 element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
                             *pipelineBuilder.stencil() = gDrawToStencil;
-                            pr->drawPath(fClipTarget, &pipelineBuilder, GrColor_WHITE,
-                                         viewMatrix, clipPath, stroke, false);
+
+                            GrPathRenderer::DrawPathArgs args;
+                            args.fTarget = fClipTarget;
+                            args.fResourceProvider = this->getContext()->resourceProvider();
+                            args.fPipelineBuilder = &pipelineBuilder;
+                            args.fColor = GrColor_WHITE;
+                            args.fViewMatrix = &viewMatrix;
+                            args.fPath = &clipPath;
+                            args.fStroke = &stroke;
+                            args.fAntiAlias = false;
+                            pr->drawPath(args);
                         } else {
-                            pr->stencilPath(fClipTarget, &pipelineBuilder, viewMatrix,
-                                            clipPath, stroke);
+                            GrPathRenderer::StencilPathArgs args;
+                            args.fTarget = fClipTarget;
+                            args.fResourceProvider = this->getContext()->resourceProvider();
+                            args.fPipelineBuilder = &pipelineBuilder;
+                            args.fViewMatrix = &viewMatrix;
+                            args.fPath = &clipPath;
+                            args.fStroke = &stroke;
+                            pr->stencilPath(args);
                         }
                     }
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             fClipMode = kModifyClip_StencilClipMode;
             for (int p = 0; p < passes; ++p) {
                 *pipelineBuilder.stencil() = stencilSettings[p];
 
                 if (canDrawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
                         // We need this AGP until everything is in GrBatch
                         fClipTarget->drawSimpleRect(pipelineBuilder,
                                                     GrColor_WHITE,
                                                     viewMatrix,
                                                     element->getRect());
                     } else {
-                        pr->drawPath(fClipTarget, &pipelineBuilder, GrColor_WHITE,
-                                     viewMatrix, clipPath, stroke, false);
+                        GrPathRenderer::DrawPathArgs args;
+                        args.fTarget = fClipTarget;
+                        args.fResourceProvider = this->getContext()->resourceProvider();
+                        args.fPipelineBuilder = &pipelineBuilder;
+                        args.fColor = GrColor_WHITE;
+                        args.fViewMatrix = &viewMatrix;
+                        args.fPath = &clipPath;
+                        args.fStroke = &stroke;
+                        args.fAntiAlias = false;
+                        pr->drawPath(args);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
                     fClipTarget->drawSimpleRect(pipelineBuilder,
                                                 GrColor_WHITE,
                                                 viewMatrix,
                                                 SkRect::Make(clipSpaceIBounds));
                 }
             }
@@ skipping 253 matching lines @@
     fAACache.purgeResources();
 }
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }