Create GrDraw and start fast pathing src over rects

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 "GrBlurUtils.h"
@@ skipping 22 matching lines @@
 #include "SkRRect.h"
 #include "SkRecord.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkSurface_Gpu.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkXfermode.h"
 #include "batches/GrRectBatchFactory.h"
+#include "draws/GrDrawRect.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "effects/GrTextureDomain.h"
 
 #if SK_SUPPORT_GPU
 
 enum { kDefaultImageFilterCacheSize = 32 * 1024 * 1024 };
 
 #if 0
@@ skipping 446 matching lines @@
         usePath = true;
     }
 
     GrStrokeInfo strokeInfo(paint);
 
     const SkPathEffect* pe = paint.getPathEffect();
     if (!usePath && pe && !strokeInfo.isDashed()) {
         usePath = true;
     }
 
+    if (strokeInfo.isDashed()) {
+        usePath = true;
+    }
+
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
-    GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
-        return;
-    }
-
-    fDrawContext->drawRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
+    GrDrawRect grDraw(fRenderTarget, fContext, fClip, paint, *draw.fMatrix, rect, &strokeInfo);
+    grDraw.execute(fDrawContext);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
                             const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawRRect", fContext);
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
 
@@ skipping 479 matching lines @@
     if (!SkPaint2GrPaintNoShader(context, paint, SkColor2GrColor(paint.getColor()), false,
                                  &grPaint)) {
         return;
     }
 
     grPaint.setColor(paintColor);
 
     // Setup dst rect and final matrix
     SkRect dstRect = {0, 0, dstSize.fWidth, dstSize.fHeight};
 
-    SkRect devRect;
-    viewMatrix.mapRect(&devRect, dstRect);
-
     SkMatrix matrix;
     matrix.setIDiv(bitmapPtr->width(), bitmapPtr->height());
 
     SkMatrix dstRectToSrcRect;
     if (!srcRectToDstRect.invert(&dstRectToSrcRect)) {
         return;
     }
     matrix.preConcat(dstRectToSrcRect);
 
     SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateAAFill(grPaint.getColor(),
                                                                      viewMatrix,
                                                                      matrix,
-                                                                     dstRect,
-                                                                     devRect));
+                                                                     dstRect));
 
     drawContext->drawBatch(renderTarget, clip, grPaint, batch);
 }
 
 static bool can_ignore_strict_subset_constraint(const SkBitmap& bitmap, const SkRect& subset) {
     GrTexture* tex = bitmap.getTexture();
     int width = tex ? tex->width() : bitmap.width();
     int height = tex ? tex->height() : bitmap.height();
     return subset.contains(SkRect::MakeIWH(width, height));
 }
@@ skipping 926 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