Start on replacing path+style with shape in patherenderer

src/gpu/batches/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 64 matching lines @@
     delete fAtlas;
 
 #ifdef DF_PATH_TRACKING
     SkDebugf("Cached paths: %d, freed paths: %d\n", g_NumCachedPaths, g_NumFreedPaths);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // We don't currently apply the dash or factor it into the DF key. (skbug.com/5082)
-    if (args.fStyle->pathEffect()) {
+    if (args.fShape->style().pathEffect()) {
         return false;
     }
     // TODO: Support inverse fill
     if (!args.fShaderCaps->shaderDerivativeSupport() || !args.fAntiAlias ||
-        args.fStyle->isSimpleHairline() || args.fPath->isInverseFillType() ||
-        args.fPath->isVolatile()) {
+        args.fShape->style().isSimpleHairline() || args.fShape->mayBeInverseFilledAfterStyling() ||
+        !args.fShape->hasUnstyledKey()) {
         return false;
     }
 
     // currently don't support perspective
     if (args.fViewMatrix->hasPerspective()) {
         return false;
     }
 
     // only support paths with bounds within kMediumMIP by kMediumMIP,
     // scaled to have bounds within 2.0f*kLargeMIP by 2.0f*kLargeMIP
     // the goal is to accelerate rendering of lots of small paths that may be scaling
     SkScalar maxScale = args.fViewMatrix->getMaxScale();
     SkRect bounds;
-    args.fStyle->adjustBounds(&bounds, args.fPath->getBounds());
+    args.fShape->styledBounds(&bounds);
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
 
     return maxDim <= kMediumMIP && maxDim * maxScale <= 2.0f*kLargeMIP;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // padding around path bounds to allow for antialiased pixels
 static const SkScalar kAntiAliasPad = 1.0f;
 
@@ skipping 409 matching lines @@
 
     typedef GrVertexBatch INHERITED;
 };
 
 bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
                               "GrAADistanceFieldPathRenderer::onDrawPath");
     SkASSERT(!args.fDrawContext->isUnifiedMultisampled());
 
     // we've already bailed on inverse filled paths, so this is safe
-    if (args.fPath->isEmpty()) {
-        return true;
-    }
+    SkASSERT(!args.fShape->isEmpty());
 
     if (!fAtlas) {
         fAtlas = args.fResourceProvider->createAtlas(kAlpha_8_GrPixelConfig,
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &GrAADistanceFieldPathRenderer::HandleEviction,
                                                      (void*)this);
         if (!fAtlas) {
             return false;
         }
     }
 
+    const GrStyle& style = args.fShape->style();
     // It's ok to ignore style's path effect because canDrawPath filtered out path effects.
-    AADistanceFieldPathBatch::Geometry geometry(args.fStyle->strokeRec());
-    if (args.fStyle->isSimpleFill()) {
-        geometry.fPath = *args.fPath;
-    } else {
-        args.fStyle->strokeRec().applyToPath(&geometry.fPath, *args.fPath);
+    AADistanceFieldPathBatch::Geometry geometry(style.strokeRec());
+    args.fShape->asPath(&geometry.fPath);
+    // Note: this is the generation ID of the _original_ path. When a new path is
+    // generated due to stroking it is important that the original path's id is used
+    // for caching.
+    geometry.fGenID = geometry.fPath.getGenerationID();
+    if (!style.isSimpleFill()) {
+        style.strokeRec().applyToPath(&geometry.fPath, geometry.fPath);
     }
     geometry.fColor = args.fColor;
     geometry.fAntiAlias = args.fAntiAlias;
-    // Note: this is the generation ID of the _original_ path. When a new path is
-    // generated due to stroking it is important that the original path's id is used
-    // for caching.
-    geometry.fGenID = args.fPath->getGenerationID();
 
     SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry,
                                                                      *args.fViewMatrix, fAtlas,
                                                                      &fPathCache, &fPathList,
                                                                      args.fGammaCorrect));
 
     GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fDrawContext->drawBatch(pipelineBuilder, *args.fClip, batch);
@@ skipping 72 matching lines @@
     geometry.fGenID = random->nextU();
 
     return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList,
                                             gammaCorrect);
 }
 
 #endif