Remove unpremul/remul from SkArithmeticMode, both raster and GPU, since the SVG spec actually defin…

src/effects/SkArithmeticMode.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkArithmeticMode.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
@@ skipping 77 matching lines @@
                                  int count, const SkAlpha aaCoverage[]) const {
     SkScalar k1 = fK[0] / 255;
     SkScalar k2 = fK[1];
     SkScalar k3 = fK[2];
     SkScalar k4 = fK[3] * 255;
 
     for (int i = 0; i < count; ++i) {
         if ((NULL == aaCoverage) || aaCoverage[i]) {
             SkPMColor sc = src[i];
             SkPMColor dc = dst[i];
-            int sa = SkGetPackedA32(sc);
-            int da = SkGetPackedA32(dc);
-
-            int srcNeedsUnpremul = needsUnpremul(sa);
-            int dstNeedsUnpremul = needsUnpremul(da);
 
             int a, r, g, b;
 
-            if (!srcNeedsUnpremul && !dstNeedsUnpremul) {
-                a = arith(k1, k2, k3, k4, sa, da);
+            if (false) {
+                int sa = SkGetPackedA32(sc);
+                int da = SkGetPackedA32(dc);
+
+                int srcNeedsUnpremul = needsUnpremul(sa);
+                int dstNeedsUnpremul = needsUnpremul(da);
+
+                if (!srcNeedsUnpremul && !dstNeedsUnpremul) {
+                    a = arith(k1, k2, k3, k4, sa, da);
+                    r = arith(k1, k2, k3, k4, SkGetPackedR32(sc), SkGetPackedR32(dc));
+                    g = arith(k1, k2, k3, k4, SkGetPackedG32(sc), SkGetPackedG32(dc));
+                    b = arith(k1, k2, k3, k4, SkGetPackedB32(sc), SkGetPackedB32(dc));
+                } else {
+                    int sr = SkGetPackedR32(sc);
+                    int sg = SkGetPackedG32(sc);
+                    int sb = SkGetPackedB32(sc);
+                    if (srcNeedsUnpremul) {
+                        SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(sa);
+                        sr = SkUnPreMultiply::ApplyScale(scale, sr);
+                        sg = SkUnPreMultiply::ApplyScale(scale, sg);
+                        sb = SkUnPreMultiply::ApplyScale(scale, sb);
+                    }
+
+                    int dr = SkGetPackedR32(dc);
+                    int dg = SkGetPackedG32(dc);
+                    int db = SkGetPackedB32(dc);
+                    if (dstNeedsUnpremul) {
+                        SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(da);
+                        dr = SkUnPreMultiply::ApplyScale(scale, dr);
+                        dg = SkUnPreMultiply::ApplyScale(scale, dg);
+                        db = SkUnPreMultiply::ApplyScale(scale, db);
+                    }
+
+                    a = arith(k1, k2, k3, k4, sa, da);
+                    r = arith(k1, k2, k3, k4, sr, dr);
+                    g = arith(k1, k2, k3, k4, sg, dg);
+                    b = arith(k1, k2, k3, k4, sb, db);
+                }
+            } else {
+                a = arith(k1, k2, k3, k4, SkGetPackedA32(sc), SkGetPackedA32(dc));
                 r = arith(k1, k2, k3, k4, SkGetPackedR32(sc), SkGetPackedR32(dc));
+                r = SkMin32(r, a);
                 g = arith(k1, k2, k3, k4, SkGetPackedG32(sc), SkGetPackedG32(dc));
+                g = SkMin32(g, a);
                 b = arith(k1, k2, k3, k4, SkGetPackedB32(sc), SkGetPackedB32(dc));
-            } else {
-                int sr = SkGetPackedR32(sc);
-                int sg = SkGetPackedG32(sc);
-                int sb = SkGetPackedB32(sc);
-                if (srcNeedsUnpremul) {
-                    SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(sa);
-                    sr = SkUnPreMultiply::ApplyScale(scale, sr);
-                    sg = SkUnPreMultiply::ApplyScale(scale, sg);
-                    sb = SkUnPreMultiply::ApplyScale(scale, sb);
-                }
-
-                int dr = SkGetPackedR32(dc);
-                int dg = SkGetPackedG32(dc);
-                int db = SkGetPackedB32(dc);
-                if (dstNeedsUnpremul) {
-                    SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(da);
-                    dr = SkUnPreMultiply::ApplyScale(scale, dr);
-                    dg = SkUnPreMultiply::ApplyScale(scale, dg);
-                    db = SkUnPreMultiply::ApplyScale(scale, db);
-                }
-
-                a = arith(k1, k2, k3, k4, sa, da);
-                r = arith(k1, k2, k3, k4, sr, dr);
-                g = arith(k1, k2, k3, k4, sg, dg);
-                b = arith(k1, k2, k3, k4, sb, db);
+                b = SkMin32(b, a);
             }
 
             // apply antialias coverage if necessary
             if (aaCoverage && 0xFF != aaCoverage[i]) {
                 int scale = aaCoverage[i] + (aaCoverage[i] >> 7);
                 a = blend(a, SkGetPackedA32(sc), scale);
                 r = blend(r, SkGetPackedR32(sc), scale);
                 g = blend(g, SkGetPackedG32(sc), scale);
                 b = blend(b, SkGetPackedB32(sc), scale);
             }
 
             // turn the result back into premul
-            if (0xFF != a) {
+            if (false /* 0xFF != a */) {
                 int scale = a + (a >> 7);
                 r = SkAlphaMul(r, scale);
                 g = SkAlphaMul(g, scale);
                 b = SkAlphaMul(b, scale);
             }
             dst[i] = SkPackARGB32(a, r, g, b);
         }
     }
 }
 
@@ skipping 195 matching lines @@
     GrAssert(NULL != dstColor);
     fKUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                 kVec4f_GrSLType, "k");
     const char* kUni = builder->getUniformCStr(fKUni);
 
     // We don't try to optimize for this case at all
     if (NULL == inputColor) {
         builder->fsCodeAppendf("\t\tconst vec4 src = %s;\n", GrGLSLOnesVecf(4));
     } else {
         builder->fsCodeAppendf("\t\tvec4 src = %s;\n", inputColor);
-        builder->fsCodeAppendf("\t\tsrc.rgb = clamp(src.rgb / src.a, 0.0, 1.0);\n");
+        if (false) {
+            builder->fsCodeAppendf("\t\tsrc.rgb = clamp(src.rgb / src.a, 0.0, 1.0);\n");
+        }
     }
 
     builder->fsCodeAppendf("\t\tvec4 dst = %s;\n", dstColor);
-    builder->fsCodeAppendf("\t\tdst.rgb = clamp(dst.rgb / dst.a, 0.0, 1.0);\n");
+    if (false) {
+        builder->fsCodeAppendf("\t\tdst.rgb = clamp(dst.rgb / dst.a, 0.0, 1.0);\n");
+    }
 
     builder->fsCodeAppendf("\t\t%s = %s.x * src * dst + %s.y * src + %s.z * dst + %s.w;\n", outputColor, kUni, kUni, kUni, kUni);
     builder->fsCodeAppendf("\t\t%s = clamp(%s, 0.0, 1.0);\n", outputColor, outputColor);
-    builder->fsCodeAppendf("\t\t%s.rgb *= %s.a;\n", outputColor, outputColor);
+    if (false) {
+        builder->fsCodeAppendf("\t\t%s.rgb *= %s.a;\n", outputColor, outputColor);
+    } else {
+        builder->fsCodeAppendf("\t\t%s.rgb = min(%s.rgb, %s.a);\n", outputColor, outputColor, outputColor);
+    }
 }
 
 void GrGLArithmeticEffect::setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) {
     const GrArithmeticEffect& arith = drawEffect.castEffect<GrArithmeticEffect>();
     uman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
     GrTexture* bgTex = arith.backgroundTexture();
     if (bgTex) {
         fBackgroundEffectMatrix.setData(uman,
                                         GrEffect::MakeDivByTextureWHMatrix(bgTex),
                                         drawEffect,
@@ skipping 42 matching lines @@
                                              background);
     }
     return true;
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkArithmeticMode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkArithmeticMode_scalar)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END