add SkPath::isRRect

src/core/SkPath.cpp

 /*
  * Copyright 2006 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 "SkBuffer.h"
 #include "SkErrorInternals.h"
 #include "SkGeometry.h"
@@ skipping 1054 matching lines @@
     this->addRRect(rrect, dir, dir == kCW_Direction ? 6 : 7);
 }
 
 void SkPath::addRRect(const SkRRect &rrect, Direction dir, unsigned startIndex) {
         assert_known_direction(dir);
 
         if (rrect.isEmpty()) {
             return;
         }
 
+        bool isRRect = hasOnlyMoveTos();
         const SkRect& bounds = rrect.getBounds();
 
         if (rrect.isRect()) {
             // degenerate(rect) => radii points are collapsing
             this->addRect(bounds, dir, (startIndex + 1) / 2);
         } else if (rrect.isOval()) {
             // degenerate(oval) => line points are collapsing
             this->addOval(bounds, dir, startIndex / 2);
         } else {
             fFirstDirection = this->hasOnlyMoveTos() ?
@@ skipping 27 matching lines @@
                 this->conicTo(rectIter.next(), rrectIter.next(), weight);
                 // final lineTo handled by close().
             } else {
                 for (unsigned i = 0; i < 4; ++i) {
                     this->lineTo(rrectIter.next());
                     this->conicTo(rectIter.next(), rrectIter.next(), weight);
                 }
             }
             this->close();
 
+            SkPathRef::Editor ed(&fPathRef);
+            ed.setIsRRect(isRRect);
+
             SkASSERT(this->countVerbs() == initialVerbCount + kVerbs);
         }
 
         SkDEBUGCODE(fPathRef->validate();)
 }
 
 bool SkPath::hasOnlyMoveTos() const {
     int count = fPathRef->countVerbs();
     const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbsMemBegin();
     for (int i = 0; i < count; ++i) {
@@ skipping 722 matching lines @@
             }
             fLastPt = fMoveTo;
             break;
     }
     fPts = srcPts;
     return (Verb)verb;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPath::RawIter::RawIter() {
-#ifdef SK_DEBUG
-    fPts = nullptr;
-    fConicWeights = nullptr;
-#endif
-    // need to init enough to make next() harmlessly return kDone_Verb
-    fVerbs = nullptr;
-    fVerbStop = nullptr;
-}
-
-SkPath::RawIter::RawIter(const SkPath& path) {
-    this->setPath(path);
-}
-
-void SkPath::RawIter::setPath(const SkPath& path) {
-    fPts = path.fPathRef->points();
-    fVerbs = path.fPathRef->verbs();
-    fVerbStop = path.fPathRef->verbsMemBegin();
-    fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
-}
-
-SkPath::Verb SkPath::RawIter::next(SkPoint pts[4]) {
-    SkASSERT(pts);
-    if (fVerbs == fVerbStop) {
-        return kDone_Verb;
-    }
-
-    // fVerbs points one beyond next verb so decrement first.
-    unsigned verb = *(--fVerbs);
-    const SkPoint* srcPts = fPts;
-
-    switch (verb) {
-        case kMove_Verb:
-            pts[0] = srcPts[0];
-            srcPts += 1;
-            break;
-        case kLine_Verb:
-            pts[0] = srcPts[-1];
-            pts[1] = srcPts[0];
-            srcPts += 1;
-            break;
-        case kConic_Verb:
-            fConicWeights += 1;
-            // fall-through
-        case kQuad_Verb:
-            pts[0] = srcPts[-1];
-            pts[1] = srcPts[0];
-            pts[2] = srcPts[1];
-            srcPts += 2;
-            break;
-        case kCubic_Verb:
-            pts[0] = srcPts[-1];
-            pts[1] = srcPts[0];
-            pts[2] = srcPts[1];
-            pts[3] = srcPts[2];
-            srcPts += 3;
-            break;
-        case kClose_Verb:
-            break;
-        case kDone_Verb:
-            SkASSERT(fVerbs == fVerbStop);
-            break;
-    }
-    fPts = srcPts;
-    return (Verb)verb;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 /*
     Format in compressed buffer: [ptCount, verbCount, pts[], verbs[]]
 */
 
 size_t SkPath::writeToMemory(void* storage) const {
     SkDEBUGCODE(this->validate();)
 
     if (nullptr == storage) {
         const int byteCount = sizeof(int32_t) + fPathRef->writeSize();
         return SkAlign4(byteCount);
@@ skipping 952 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }