Stop supporting HW dither

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 365 matching lines @@
     fDrawContext.reset(fRenderTarget->getContext()->drawContext(&this->surfaceProps()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     fDrawContext->drawPaint(fRenderTarget, fClip, grPaint, *draw.fMatrix);
 }
 
 // must be in SkCanvas::PointMode order
 static const GrPrimitiveType gPointMode2PrimtiveType[] = {
     kPoints_GrPrimitiveType,
     kLines_GrPrimitiveType,
@@ skipping 28 matching lines @@
     CHECK_SHOULD_DRAW(draw);
 
     SkScalar width = paint.getStrokeWidth();
     if (width < 0) {
         return;
     }
 
     if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
         GrStrokeInfo strokeInfo(paint, SkPaint::kStroke_Style);
         GrPaint grPaint;
-        if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true,
-                             &grPaint)) {
+        if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
             return;
         }
         SkPath path;
         path.setIsVolatile(true);
         path.moveTo(pts[0]);
         path.lineTo(pts[1]);
         fDrawContext->drawPath(fRenderTarget, fClip, grPaint, *draw.fMatrix, path, strokeInfo);
         return;
     }
 
     // we only handle non-antialiased hairlines and paints without path effects or mask filters,
     // else we let the SkDraw call our drawPath()
     if (width > 0 || paint.getPathEffect() || paint.getMaskFilter() || 
         (paint.isAntiAlias() && needs_antialiasing(mode, count, pts))) {
         draw.drawPoints(mode, count, pts, paint, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     fDrawContext->drawVertices(fRenderTarget,
                                fClip,
                                grPaint,
                                *draw.fMatrix,
                                gPointMode2PrimtiveType[mode],
                                SkToS32(count),
                                (SkPoint*)pts,
@@ skipping 42 matching lines @@
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     fDrawContext->drawRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     GrStrokeInfo strokeInfo(paint);
     if (paint.getMaskFilter()) {
         // try to hit the fast path for drawing filtered round rects
 
         SkRRect devRRect;
         if (rect.transform(*draw.fMatrix, &devRRect)) {
             if (devRRect.allCornersCircular()) {
@@ skipping 50 matching lines @@
 
 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                              const SkRRect& inner, const SkPaint& paint) {
     SkStrokeRec stroke(paint);
     if (stroke.isFillStyle()) {
 
         CHECK_FOR_ANNOTATION(paint);
         CHECK_SHOULD_DRAW(draw);
 
         GrPaint grPaint;
-        if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true,
-                             &grPaint)) {
+        if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
             return;
         }
 
         if (nullptr == paint.getMaskFilter() && nullptr == paint.getPathEffect()) {
             fDrawContext->drawDRRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, outer, inner);
             return;
         }
     }
 
     SkPath path;
@@ skipping 31 matching lines @@
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     fDrawContext->drawOval(fRenderTarget, fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
 }
 
 #include "SkMaskFilter.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 334 matching lines @@
         fp.reset(GrBicubicEffect::Create(grPaint.getProcessorDataManager(), texture,
                                          SkMatrix::I(),
                                          tm));
     } else {
         fp.reset(GrSimpleTextureEffect::Create(grPaint.getProcessorDataManager(), texture,
                                                SkMatrix::I(), params));
     }
 
     // The bitmap read has to be first
     grPaint.addColorFragmentProcessor(fp);
-    if (!SkPaint2GrPaintNoShader(context, renderTarget, paint, SkColor2GrColor(paint.getColor()),
-                                 false, &grPaint)) {
+    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);
@@ skipping 325 matching lines @@
                                          tileModes));
     } else {
         fp.reset(GrSimpleTextureEffect::Create(grPaint.getProcessorDataManager(), texture,
                                                SkMatrix::I(), params));
     }
 
     grPaint.addColorFragmentProcessor(fp);
     bool alphaOnly = !(kAlpha_8_SkColorType == bitmap.colorType());
     GrColor paintColor = (alphaOnly) ? SkColor2GrColorJustAlpha(paint.getColor()) :
                                        SkColor2GrColor(paint.getColor());
-    if (!SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint, paintColor, false,
-                                 &grPaint)) {
+    if (!SkPaint2GrPaintNoShader(this->context(), paint, paintColor, false, &grPaint)) {
         return;
     }
 
     fDrawContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, viewMatrix, dstRect,
                                       paintRect);
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 int width, int height,
                                 const SkImageFilter* filter,
@@ skipping 52 matching lines @@
             left += offset.x();
             top += offset.y();
         } else {
             return;
         }
     }
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(texture, SkMatrix::I());
 
-    if (!SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint,
+    if (!SkPaint2GrPaintNoShader(this->context(), paint,
                                  SkColor2GrColorJustAlpha(paint.getColor()), false, &grPaint)) {
         return;
     }
 
     fDrawContext->drawNonAARectToRect(fRenderTarget,
                                       fClip,
                                       grPaint,
                                       SkMatrix::I(),
                                       SkRect::MakeXYWH(SkIntToScalar(left),
                                                        SkIntToScalar(top),
@@ skipping 94 matching lines @@
             x += offset.fX;
             y += offset.fY;
         } else {
             return;
         }
     }
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(devTex, SkMatrix::I());
 
-    if (!SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint,
+    if (!SkPaint2GrPaintNoShader(this->context(), paint,
                                  SkColor2GrColorJustAlpha(paint.getColor()), false, &grPaint)) {
         return;
     }
 
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
                                       SkIntToScalar(h));
 
     // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
@@ skipping 116 matching lines @@
     // If both textures and vertex-colors are nullptr, strokes hairlines with the paint's color.
     if ((nullptr == texs || nullptr == paint.getShader()) && nullptr == colors) {
 
         texs = nullptr;
 
         SkPaint copy(paint);
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
 
         // we ignore the shader if texs is null.
-        if (!SkPaint2GrPaintNoShader(this->context(), fRenderTarget, copy,
+        if (!SkPaint2GrPaintNoShader(this->context(), copy,
                                      SkColor2GrColor(copy.getColor()), nullptr == colors, &grPaint)) {
             return;
         }
 
         primType = kLines_GrPrimitiveType;
         int triangleCount = 0;
         int n = (nullptr == indices) ? vertexCount : indexCount;
         switch (vmode) {
             case SkCanvas::kTriangles_VertexMode:
                 triangleCount = n / 3;
@@ skipping 21 matching lines @@
             auxIndices[i + 3] = state.f2;
             auxIndices[i + 4] = state.f2;
             auxIndices[i + 5] = state.f0;
             i += 6;
         }
     } else {
         outIndices = indices;
         primType = gVertexMode2PrimitiveType[vmode];
 
         if (nullptr == texs || nullptr == paint.getShader()) {
-            if (!SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint,
+            if (!SkPaint2GrPaintNoShader(this->context(), paint,
                                          SkColor2GrColor(paint.getColor()),
                                          nullptr == colors, &grPaint)) {
                 return;
             }
         } else {
-            if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix,
+            if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix,
                                  nullptr == colors, &grPaint)) {
                 return;
             }
         }
     }
 
 #if 0
     if (xmode && texs && colors) {
         if (!SkXfermode::IsMode(xmode, SkXfermode::kModulate_Mode)) {
             SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
@@ skipping 39 matching lines @@
         return;
     }
 
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
     
     SkPaint p(paint);
     p.setShader(atlas->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref();
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, p, *draw.fMatrix, !colors, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), p, *draw.fMatrix, !colors, &grPaint)) {
         return;
     }
     
     SkDEBUGCODE(this->validate();)
     
 #if 0
     if (colors) {
         if (SkXfermode::kModulate_Mode != mode) {
             SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
             return;
         }
     }
 #endif
     
     fDrawContext->drawAtlas(fRenderTarget, fClip, grPaint, *draw.fMatrix,
                             count, xform, texRect, colors);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                            size_t byteLength, SkScalar x, SkScalar y,
                            const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
                            (const char *)text, byteLength, x, y, draw.fClip->getBounds());
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPosText", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawPosText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
                               (const char *)text, byteLength, pos, scalarsPerPos, offset,
                               draw.fClip->getBounds());
 }
 
@@ skipping 127 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