The Tor Browser: gfx/skia/trunk/src/pathops/SkOpContour.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pathops/SkOpContour.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pathops/SkOpContour.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpContour_DEFINED
 #define SkOpContour_DEFINED
 #include "SkOpSegment.h"
 #include "SkTArray.h"
 class SkIntersections;
 class SkOpContour;
 class SkPathWriter;
 struct SkCoincidence {
     SkOpContour* fOther;
     int fSegments[2];
     double fTs[2][2];
     SkPoint fPts[2];
 };
 class SkOpContour {
 public:
     SkOpContour() {
         reset();
 #ifdef SK_DEBUG
         fID = ++SkPathOpsDebug::gContourID;
 #endif
     }
     bool operator<(const SkOpContour& rh) const {
         return fBounds.fTop == rh.fBounds.fTop
                 ? fBounds.fLeft < rh.fBounds.fLeft
                 : fBounds.fTop < rh.fBounds.fTop;
     }
     bool addCoincident(int index, SkOpContour* other, int otherIndex,
                        const SkIntersections& ts, bool swap);
     void addCoincidentPoints();
     void addCross(const SkOpContour* crosser) {
 #ifdef DEBUG_CROSS
         for (int index = 0; index < fCrosses.count(); ++index) {
             SkASSERT(fCrosses[index] != crosser);
         }
 #endif
         fCrosses.push_back(crosser);
     }
     void addCubic(const SkPoint pts[4]) {
         fSegments.push_back().addCubic(pts, fOperand, fXor);
         fContainsCurves = fContainsCubics = true;
     }
     int addLine(const SkPoint pts[2]) {
         fSegments.push_back().addLine(pts, fOperand, fXor);
         return fSegments.count();
     }
     void addOtherT(int segIndex, int tIndex, double otherT, int otherIndex) {
         fSegments[segIndex].addOtherT(tIndex, otherT, otherIndex);
     }
     bool addPartialCoincident(int index, SkOpContour* other, int otherIndex,
                        const SkIntersections& ts, int ptIndex, bool swap);
     int addQuad(const SkPoint pts[3]) {
         fSegments.push_back().addQuad(pts, fOperand, fXor);
         fContainsCurves = true;
         return fSegments.count();
     }
     int addT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT) {
         setContainsIntercepts();
         return fSegments[segIndex].addT(&other->fSegments[otherIndex], pt, newT);
     }
     int addSelfT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT) {
         setContainsIntercepts();
         return fSegments[segIndex].addSelfT(&other->fSegments[otherIndex], pt, newT);
     }
     const SkPathOpsBounds& bounds() const {
         return fBounds;
     }
     void calcCoincidentWinding();
     void calcPartialCoincidentWinding();
     void checkEnds() {
         if (!fContainsCurves) {
             return;
         }
         int segmentCount = fSegments.count();
         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
             SkOpSegment* segment = &fSegments[sIndex];
             if (segment->verb() == SkPath::kLine_Verb) {
                 continue;
             }
             if (segment->done()) {
                 continue;   // likely coincident, nothing to do
             }
             segment->checkEnds();
         }
     }
     // if same point has different T values, choose a common T
     void checkTiny() {
         int segmentCount = fSegments.count();
         if (segmentCount <= 2) {
             return;
         }
         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
             fSegments[sIndex].checkTiny();
         }
     }
     void complete() {
         setBounds();
         fContainsIntercepts = false;
     }
     bool containsCubics() const {
         return fContainsCubics;
     }
     bool crosses(const SkOpContour* crosser) const {
         for (int index = 0; index < fCrosses.count(); ++index) {
             if (fCrosses[index] == crosser) {
                 return true;
             }
         }
         return false;
     }
     bool done() const {
         return fDone;
     }
     const SkPoint& end() const {
         const SkOpSegment& segment = fSegments.back();
         return segment.pts()[SkPathOpsVerbToPoints(segment.verb())];
     }
     void fixOtherTIndex() {
         int segmentCount = fSegments.count();
         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
             fSegments[sIndex].fixOtherTIndex();
         }
     }
     void joinCoincidence() {
         joinCoincidence(fCoincidences, false);
         joinCoincidence(fPartialCoincidences, true);
     }
     SkOpSegment* nonVerticalSegment(int* start, int* end);
     bool operand() const {
         return fOperand;
     }
     void reset() {
         fSegments.reset();
         fBounds.set(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, SK_ScalarMax);
         fContainsCurves = fContainsCubics = fContainsIntercepts = fDone = false;
     }
     SkTArray<SkOpSegment>& segments() {
         return fSegments;
     }
     void setContainsIntercepts() {
         fContainsIntercepts = true;
     }
     void setOperand(bool isOp) {
         fOperand = isOp;
     }
     void setOppXor(bool isOppXor) {
         fOppXor = isOppXor;
         int segmentCount = fSegments.count();
         for (int test = 0; test < segmentCount; ++test) {
             fSegments[test].setOppXor(isOppXor);
         }
     }
     void setXor(bool isXor) {
         fXor = isXor;
     }
     void sortSegments();
     const SkPoint& start() const {
         return fSegments.front().pts()[0];
     }
     void toPath(SkPathWriter* path) const;
     void toPartialBackward(SkPathWriter* path) const {
         int segmentCount = fSegments.count();
         for (int test = segmentCount - 1; test >= 0; --test) {
             fSegments[test].addCurveTo(1, 0, path, true);
         }
     }
     void toPartialForward(SkPathWriter* path) const {
         int segmentCount = fSegments.count();
         for (int test = 0; test < segmentCount; ++test) {
             fSegments[test].addCurveTo(0, 1, path, true);
         }
     }
     void topSortableSegment(const SkPoint& topLeft, SkPoint* bestXY, SkOpSegment** topStart);
     SkOpSegment* undoneSegment(int* start, int* end);
     int updateSegment(int index, const SkPoint* pts) {
         SkOpSegment& segment = fSegments[index];
         segment.updatePts(pts);
         return SkPathOpsVerbToPoints(segment.verb()) + 1;
     }
 #if DEBUG_TEST
     SkTArray<SkOpSegment>& debugSegments() {
         return fSegments;
     }
 #endif
 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY
     void debugShowActiveSpans() {
         for (int index = 0; index < fSegments.count(); ++index) {
             fSegments[index].debugShowActiveSpans();
         }
     }
 #endif
 #if DEBUG_SHOW_WINDING
     int debugShowWindingValues(int totalSegments, int ofInterest);
     static void debugShowWindingValues(const SkTArray<SkOpContour*, true>& contourList);
 #endif
 private:
     void calcCommonCoincidentWinding(const SkCoincidence& );
     void joinCoincidence(const SkTArray<SkCoincidence, true>& , bool partial);
     void setBounds();
     SkTArray<SkOpSegment> fSegments;
     SkTArray<SkOpSegment*, true> fSortedSegments;
     int fFirstSorted;
     SkTArray<SkCoincidence, true> fCoincidences;
     SkTArray<SkCoincidence, true> fPartialCoincidences;
     SkTArray<const SkOpContour*, true> fCrosses;
     SkPathOpsBounds fBounds;
     bool fContainsIntercepts;  // FIXME: is this used by anybody?
     bool fContainsCubics;
     bool fContainsCurves;
     bool fDone;
     bool fOperand;  // true for the second argument to a binary operator
     bool fXor;
     bool fOppXor;
 #ifdef SK_DEBUG
     int fID;
 #endif
 };
 #endif

The Tor Browser / annotate

gfx/skia/trunk/src/pathops/SkOpContour.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pathops/SkOpContour.h