optimize pathops coverage

src/pathops/SkIntersections.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkIntersections_DEFINE
 #define SkIntersections_DEFINE
 
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsPoint.h"
 #include "SkPathOpsQuad.h"
 
 class SkIntersections {
 public:
     SkIntersections()
         : fSwap(0)
 #ifdef SK_DEBUG
         , fDepth(0)
 #endif
     {
         sk_bzero(fPt, sizeof(fPt));
         sk_bzero(fT, sizeof(fT));
         sk_bzero(fIsCoincident, sizeof(fIsCoincident));
-        sk_bzero(&fIsNear, sizeof(fIsNear));
         reset();
         fMax = 0;  // require that the caller set the max
     }
 
     class TArray {
     public:
         explicit TArray(const double ts[9]) : fTArray(ts) {}
         double operator[](int n) const {
             return fTArray[n];
         }
         const double* fTArray;
     };
     TArray operator[](int n) const { return TArray(fT[n]); }
 
     void set(const SkIntersections& i) {
         memcpy(fPt, i.fPt, sizeof(fPt));
         memcpy(fT, i.fT, sizeof(fT));
         memcpy(fIsCoincident, i.fIsCoincident, sizeof(fIsCoincident));
-        memcpy(&fIsNear, &i.fIsNear, sizeof(fIsNear));
         fUsed = i.fUsed;
         fMax = i.fMax;
         fSwap = i.fSwap;
         SkDEBUGCODE(fDepth = i.fDepth);
     }
 
     void allowNear(bool nearAllowed) {
         fAllowNear = nearAllowed;
     }
 
@@ skipping 56 matching lines @@
             return insert(two, one, pt);
         } else {
             return insert(one, two, pt);
         }
     }
 
     bool isCoincident(int index) {
         return (fIsCoincident[0] & 1 << index) != 0;
     }
 
-    bool isNear(int index) {
-        return (fIsNear & 1 << index) != 0;
-    }
-
     int lineHorizontal(const SkPoint a[2], SkScalar left, SkScalar right, SkScalar y,
                        bool flipped) {
         SkDLine line;
         line.set(a);
         fMax = 2;
         return horizontal(line, left, right, y, flipped);
     }
 
     int lineVertical(const SkPoint a[2], SkScalar top, SkScalar bottom, SkScalar x, bool flipped) {
         SkDLine line;
@@ skipping 135 matching lines @@
     bool cubicExactEnd(const SkDCubic& cubic1, bool start, const SkDCubic& cubic2);
     void cubicNearEnd(const SkDCubic& cubic1, bool start, const SkDCubic& cubic2, const SkDRect& );
     void cleanUpParallelLines(bool parallel);
     void computePoints(const SkDLine& line, int used);
     // used by addCoincident to remove ordinary intersections in range
  //   void remove(double one, double two, const SkDPoint& startPt, const SkDPoint& endPt);
 
     SkDPoint fPt[9];  // FIXME: since scans store points as SkPoint, this should also
     double fT[2][9];
     uint16_t fIsCoincident[2];  // bit set for each curve's coincident T
-    uint16_t fIsNear;  // bit set for each T if 2nd curve's point is near but not equal to 1st
     unsigned char fUsed;
     unsigned char fMax;
     bool fAllowNear;
     bool fSwap;
 #ifdef SK_DEBUG
     int fDepth;
 #endif
 };
 
 extern int (SkIntersections::*CurveRay[])(const SkPoint[], const SkDLine& );
 extern int (SkIntersections::*CurveVertical[])(const SkPoint[], SkScalar top, SkScalar bottom,
             SkScalar x, bool flipped);
 
 #endif