Fix alpha computation in SkArithmeticMode.

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 "SkString.h"
@@ skipping 55 matching lines @@
     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(sa);
+            int dstNeedsUnpremul = needsUnpremul(da);
 
             int a, r, g, b;
 
             if (!srcNeedsUnpremul && !dstNeedsUnpremul) {
-                a = arith(k1, k2, k3, k4, sa, sa);
+                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, sa);
+                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);
             }
 
             // 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);
@@ skipping 67 matching lines @@
             return SkNEW_ARGS(SkArithmeticMode_dst, (i3, i4));
         }
         if (0 == i3) {
             return SkNEW_ARGS(SkArithmeticMode_src, (i2, i4));
         }
         return SkNEW_ARGS(SkArithmeticMode_linear, (i2, i3, i4));
 #endif
     }
     return SkNEW_ARGS(SkArithmeticMode_scalar, (k1, k2, k3, k4));
 }