Make GrStrokeInfo inherit from SkStrokeRec

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "GrContext.h"
@@ skipping 499 matching lines @@
                     maskRect.roundOut(&finalIRect);
                     if (draw.fClip->quickReject(finalIRect)) {
                         // clipped out
                         return;
                     }
                     if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext,
                                                                         fRenderTarget,
                                                                         &grPaint,
                                                                         fClip,
                                                                         *draw.fMatrix,
-                                                                        strokeInfo.getStrokeRec(),
+                                                                        strokeInfo,
                                                                         devRRect)) {
                         return;
                     }
                 }
 
             }
         }
 
     }
 
@@ skipping 250 matching lines @@
     SkTLazy<SkPath> tmpPath;
     SkTLazy<SkPath> effectPath;
     SkPathEffect* pathEffect = paint.getPathEffect();
 
     SkMatrix viewMatrix = origViewMatrix;
 
     if (prePathMatrix) {
         // stroking, path effects, and blurs are supposed to be applied *after* the prePathMatrix.
         // The pre-path-matrix also should not affect shading.
         if (NULL == paint.getMaskFilter() && NULL == pathEffect && NULL == paint.getShader() &&
-            (strokeInfo.getStrokeRec().isFillStyle() ||
-             strokeInfo.getStrokeRec().isHairlineStyle())) {
+            (strokeInfo.isFillStyle() || strokeInfo.isHairlineStyle())) {
             viewMatrix.preConcat(*prePathMatrix);
         } else {
             SkPath* result = pathPtr;
 
             if (!pathIsMutable) {
                 result = tmpPath.init();
                 result->setIsVolatile(true);
                 pathIsMutable = true;
             }
             // should I push prePathMatrix on our MV stack temporarily, instead
             // of applying it here? See SkDraw.cpp
             pathPtr->transform(*prePathMatrix, result);
             pathPtr = result;
         }
     }
     // at this point we're done with prePathMatrix
     SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
 
     GrPaint grPaint;
     if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, viewMatrix, true, &grPaint)) {
         return;
     }
 
     const SkRect* cullRect = NULL;  // TODO: what is our bounds?
-    SkStrokeRec* strokePtr = strokeInfo.getStrokeRecPtr();
     if (!strokeInfo.isDashed() && pathEffect && pathEffect->filterPath(effectPath.init(), *pathPtr,
-                                                                       strokePtr, cullRect)) {
+                                                                       &strokeInfo, cullRect)) {
         pathPtr = effectPath.get();
         pathIsMutable = true;
     }
 
-    const SkStrokeRec& stroke = strokeInfo.getStrokeRec();
     if (paint.getMaskFilter()) {
-        if (!stroke.isHairlineStyle()) {
+        if (!strokeInfo.isHairlineStyle()) {
             SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
             if (strokeInfo.isDashed()) {
-                if (pathEffect->filterPath(strokedPath, *pathPtr, strokePtr, cullRect)) {
+                if (pathEffect->filterPath(strokedPath, *pathPtr, &strokeInfo, cullRect)) {
                     pathPtr = strokedPath;
                     pathIsMutable = true;
                 }
                 strokeInfo.removeDash();
             }
-            if (stroke.applyToPath(strokedPath, *pathPtr)) {
+            if (strokeInfo.applyToPath(strokedPath, *pathPtr)) {
                 pathPtr = strokedPath;
                 pathIsMutable = true;
                 strokeInfo.setFillStyle();
             }
         }
 
         // avoid possibly allocating a new path in transform if we can
         SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
         if (!pathIsMutable) {
             devPathPtr->setIsVolatile(true);
@@ skipping 12 matching lines @@
             if (clip_bounds_quick_reject(clipBounds, finalIRect)) {
                 // clipped out
                 return;
             }
 
             if (paint.getMaskFilter()->directFilterMaskGPU(fContext,
                                                            fRenderTarget,
                                                            &grPaint,
                                                            fClip,
                                                            viewMatrix,
-                                                           stroke,
+                                                           strokeInfo,
                                                            *devPathPtr)) {
                 // the mask filter was able to draw itself directly, so there's nothing
                 // left to do.
                 return;
             }
 
 
             SkAutoTUnref<GrTexture> mask(create_mask_GPU(fContext,
                                                          fRenderTarget,
                                                          maskRect,
@@ skipping 16 matching lines @@
                                   filtered)) {
                         // This path is completely drawn
                         return;
                     }
                 }
             }
         }
 
         // draw the mask on the CPU - this is a fallthrough path in case the
         // GPU path fails
-        SkPaint::Style style = stroke.isHairlineStyle() ? SkPaint::kStroke_Style :
-                                                          SkPaint::kFill_Style;
+        SkPaint::Style style = strokeInfo.isHairlineStyle() ? SkPaint::kStroke_Style :
+                                                              SkPaint::kFill_Style;
         draw_with_mask_filter(fContext, fRenderTarget, fClip, viewMatrix, *devPathPtr,
                               paint.getMaskFilter(), clipBounds, &grPaint, style);
         return;
     }
 
     fContext->drawPath(fRenderTarget, fClip, grPaint, viewMatrix, *pathPtr, strokeInfo);
 }
 
 static const int kBmpSmallTileSize = 1 << 10;
 
@@ skipping 1140 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif