Make GrStrokeInfo inherit from SkStrokeRec

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 577 matching lines @@
     }
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRect", target);
-    SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getStrokeRec().getWidth();
+    SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getWidth();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
         pipelineBuilder.getRenderTarget()->getBoundsRect(&rtRect);
         SkRect clipSpaceRTRect = rtRect;
         bool checkClip = GrClip::kWideOpen_ClipType != clip.clipType();
         if (checkClip) {
             clipSpaceRTRect.offset(SkIntToScalar(clip.origin().fX),
@@ skipping 23 matching lines @@
     }
 
     GrColor color = paint.getColor();
     SkRect devBoundRect;
     bool needAA = paint.isAntiAlias() && !pipelineBuilder.getRenderTarget()->isMultisampled();
     bool doAA = needAA && apply_aa_to_rect(target, &pipelineBuilder, &devBoundRect, rect, width,
                                            viewMatrix, color);
 
     if (doAA) {
         if (width >= 0) {
-            const SkStrokeRec& strokeRec = strokeInfo->getStrokeRec();
             fAARectRenderer->strokeAARect(target,
                                           &pipelineBuilder,
                                           color,
                                           viewMatrix,
                                           rect,
                                           devBoundRect,
-                                          strokeRec);
+                                          *strokeInfo);
         } else {
             // filled AA rect
             fAARectRenderer->fillAARect(target,
                                         &pipelineBuilder,
                                         color,
                                         viewMatrix,
                                         rect,
                                         devBoundRect);
         }
         return;
@@ skipping 393 matching lines @@
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
-    const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
-
     GrColor color = paint.getColor();
     if (!fOvalRenderer->drawRRect(target,
                                   &pipelineBuilder,
                                   color,
                                   viewMatrix,
                                   paint.isAntiAlias(),
                                   rrect,
-                                  strokeRec)) {
+                                  strokeInfo)) {
         SkPath path;
         path.addRRect(rrect);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(GrRenderTarget* rt,
@@ skipping 54 matching lines @@
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
-    const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
-
     GrColor color = paint.getColor();
     if (!fOvalRenderer->drawOval(target,
                                  &pipelineBuilder,
                                  color,
                                  viewMatrix,
                                  paint.isAntiAlias(),
                                  oval,
-                                 strokeRec)) {
+                                 strokeInfo)) {
         SkPath path;
         path.addOval(oval);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             GrPipelineBuilder* pipelineBuilder,
@@ skipping 71 matching lines @@
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER1("GrContext::drawPath", target, "Is Convex", path.isConvex());
 
     if (!strokeInfo.isDashed()) {
-        const SkStrokeRec& strokeRec = strokeInfo.getStrokeRec();
         bool useCoverageAA = paint.isAntiAlias() &&
                 !pipelineBuilder.getRenderTarget()->isMultisampled();
 
-        if (useCoverageAA && strokeRec.getWidth() < 0 && !path.isConvex()) {
+        if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
-            if (is_nested_rects(target, &pipelineBuilder, color, viewMatrix, path, strokeRec,
+            if (is_nested_rects(target, &pipelineBuilder, color, viewMatrix, path, strokeInfo,
                                 rects)) {
                 fAARectRenderer->fillAANestedRects(target, &pipelineBuilder, color, viewMatrix,
                                                    rects);
                 return;
             }
         }
         SkRect ovalRect;
         bool isOval = path.isOval(&ovalRect);
 
         if (isOval && !path.isInverseFillType()) {
             if (fOvalRenderer->drawOval(target,
                                         &pipelineBuilder,
                                         color,
                                         viewMatrix,
                                         paint.isAntiAlias(),
                                         ovalRect,
-                                        strokeRec)) {
+                                        strokeInfo)) {
                 return;
             }
         }
     }
     this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                            path, strokeInfo);
 }
 
 void GrContext::internalDrawPath(GrDrawTarget* target,
                                  GrPipelineBuilder* pipelineBuilder,
@@ skipping 24 matching lines @@
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
     GrPathRenderer* pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr,
                                                *strokeInfoPtr, false, type);
 
     GrStrokeInfo dashlessStrokeInfo(strokeInfo, false);
     if (NULL == pr && strokeInfo.isDashed()) {
         // It didn't work above, so try again with dashed stroke converted to a dashless stroke.
-        if (!strokeInfo.applyDash(tmpPath.init(), &dashlessStrokeInfo, *pathPtr)) {
+        if (!strokeInfo.applyDashToPath(tmpPath.init(), &dashlessStrokeInfo, *pathPtr)) {
             return;
         }
         pathPtr = tmpPath.get();
         if (pathPtr->isEmpty()) {
             return;
         }
         strokeInfoPtr = &dashlessStrokeInfo;
         pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *strokeInfoPtr,
                                    false, type);
     }
 
     if (NULL == pr) {
         if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*strokeInfoPtr, viewMatrix, NULL) &&
             !strokeInfoPtr->isFillStyle()) {
             // It didn't work above, so try again with stroke converted to a fill.
             if (!tmpPath.isValid()) {
                 tmpPath.init();
             }
-            SkStrokeRec* strokeRec = dashlessStrokeInfo.getStrokeRecPtr();
-            strokeRec->setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
-            if (!strokeRec->applyToPath(tmpPath.get(), *pathPtr)) {
+            dashlessStrokeInfo.setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
+            if (!dashlessStrokeInfo.applyToPath(tmpPath.get(), *pathPtr)) {
                 return;
             }
             pathPtr = tmpPath.get();
             if (pathPtr->isEmpty()) {
                 return;
             }
-            strokeRec->setFillStyle();
+            dashlessStrokeInfo.setFillStyle();
             strokeInfoPtr = &dashlessStrokeInfo;
         }
 
         // This time, allow SW renderer
         pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *strokeInfoPtr,
                                    true, type);
     }
 
     if (NULL == pr) {
 #ifdef SK_DEBUG
@@ skipping 643 matching lines @@
     geometry.fColor = GrRandomColor(random);
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif