Set analytic AA as default.

src/core/SkScan_AAAPath.cpp

 /*
  * Copyright 2016 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAntiRun.h"
 #include "SkBlitter.h"
 #include "SkEdge.h"
@@ skipping 65 matching lines @@
 In summary, our algorithm has a higher quality because it generates ground-
 truth coverages analytically. It is also faster because it has much fewer
 unnessasary horizontal scan lines. For example, given a triangle path, the
 number of scan lines in our algorithm is only about 3 + H while the
 16-supersampling algorithm has about 4H scan lines.
 
 */
 
 ///////////////////////////////////////////////////////////////////////////////
 
-inline void addAlpha(SkAlpha& alpha, SkAlpha delta) {
-    SkASSERT(alpha + (int)delta <= 0xFF);
-    alpha += delta;
+static inline void addAlpha(SkAlpha& alpha, SkAlpha delta) {
+    SkASSERT(alpha + (int)delta <= 256);

[reed1, 2016/11/07 15:31:42]

why do we have a cast on delta?

[liyuqian, 2016/11/07 16:08:00]

I think that we can also cast alpha to int? If we don't cast either of them,
then SkAlpha is only 8 bits unsigned, which means that we would never trigger
the assert.

+    alpha = SkAlphaRuns::CatchOverflow(alpha + (int)delta);
 }
 
 class AdditiveBlitter : public SkBlitter {
 public:
     virtual ~AdditiveBlitter() {}
 
     virtual SkBlitter* getRealBlitter(bool forceRealBlitter = false) = 0;
 
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], int len) = 0;
     virtual void blitAntiH(int x, int y, const SkAlpha alpha) = 0;
@@ skipping 375 matching lines @@
     // return ((((a >> 8) * (a >> 8)) >> 8) * (b >> 8)) >> 1;
     return (a >> 11) * (a >> 11) * (b >> 11);
 }
 
 // The alpha of right-triangle (a, a*b)
 static inline SkAlpha partialTriangleToAlpha(SkFixed a, SkFixed b) {
     return partialTriangleToAlpha16(a, b) >> 8;
 }
 
 static inline SkAlpha getPartialAlpha(SkAlpha alpha, SkFixed partialHeight) {
-    return (alpha * partialHeight) >> 16;
+    return (alpha * partialHeight + SK_FixedHalf) >> 16;

[reed1, 2016/11/07 15:31:42]

return SkToU8(SkFixedRoundToInt(alpha * partialHeight));

[liyuqian, 2016/11/07 16:08:00]

Done.

 }
 
 static inline SkAlpha getPartialAlpha(SkAlpha alpha, SkAlpha fullAlpha) {
     return ((uint16_t)alpha * fullAlpha) >> 8;
 }
 
 // For SkFixed that's close to SK_Fixed1, we can't convert it to alpha by just shifting right.
 // For example, when f = SK_Fixed1, right shifting 8 will get 256, but we need 255.
 // This is rarely the problem so we'll only use this for blitting rectangles.
 static inline SkAlpha f2a(SkFixed f) {
@@ skipping 846 matching lines @@
         AAAFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
 
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         AAAFillPath(path, tmp, &aaBlitter, true);
     }
 }