Add SkRacy

src/core/SkPathRef.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 "SkBuffer.h"
 #include "SkLazyPtr.h"
 #include "SkPath.h"
@@ skipping 12 matching lines @@
         pathRef->reset(copy);
     }
     fPathRef = *pathRef;
     fPathRef->fGenerationID = 0;
     SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 SkPathRef* SkPathRef::CreateEmptyImpl() {
-    SkPathRef* p = SkNEW(SkPathRef);
-    p->computeBounds();   // Preemptively avoid a race to clear fBoundsIsDirty.
-    return p;
+    return SkNEW(SkPathRef);
 }
 
 SkPathRef* SkPathRef::CreateEmpty() {
     SK_DECLARE_STATIC_LAZY_PTR(SkPathRef, empty, CreateEmptyImpl);
     return SkRef(empty.get());
 }
 
 void SkPathRef::CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
                                       const SkPathRef& src,
                                       const SkMatrix& matrix) {
@@ skipping 32 matching lines @@
         *  them as "known", rather than force the transformed path to have to
         *  recompute them.
         *
         *  Special gotchas if the path is effectively empty (<= 1 point) or
         *  if it is non-finite. In those cases bounds need to stay empty,
         *  regardless of the matrix.
         */
     if (canXformBounds) {
         (*dst)->fBoundsIsDirty = false;
         if (src.fIsFinite) {
-            matrix.mapRect(&(*dst)->fBounds, src.fBounds);
-            if (!((*dst)->fIsFinite = (*dst)->fBounds.isFinite())) {
-                (*dst)->fBounds.setEmpty();
+            matrix.mapRect((*dst)->fBounds.get(), src.fBounds);
+            if (!((*dst)->fIsFinite = (*dst)->fBounds->isFinite())) {
+                (*dst)->fBounds->setEmpty();
             }
         } else {
             (*dst)->fIsFinite = false;
-            (*dst)->fBounds.setEmpty();
+            (*dst)->fBounds->setEmpty();
         }
     } else {
         (*dst)->fBoundsIsDirty = true;
     }
 
     (*dst)->fSegmentMask = src.fSegmentMask;
 
     // It's an oval only if it stays a rect.
     (*dst)->fIsOval = src.fIsOval && matrix.rectStaysRect();
 
@@ skipping 329 matching lines @@
     SkASSERT(static_cast<ptrdiff_t>(fFreeSpace) >= 0);
     SkASSERT(reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) >= 0);
     SkASSERT((NULL == fPoints) == (NULL == fVerbs));
     SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
     SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
     SkASSERT(!(NULL == fPoints && fPointCnt));
     SkASSERT(!(NULL == fVerbs && fVerbCnt));
     SkASSERT(this->currSize() ==
                 fFreeSpace + sizeof(SkPoint) * fPointCnt + sizeof(uint8_t) * fVerbCnt);
 
-    if (!fBoundsIsDirty && !fBounds.isEmpty()) {
+    if (!fBoundsIsDirty && !fBounds->isEmpty()) {
         bool isFinite = true;
         for (int i = 0; i < fPointCnt; ++i) {
             SkASSERT(!fPoints[i].isFinite() || (
-                     fBounds.fLeft - fPoints[i].fX   < SK_ScalarNearlyZero &&
-                     fPoints[i].fX - fBounds.fRight  < SK_ScalarNearlyZero &&
-                     fBounds.fTop  - fPoints[i].fY   < SK_ScalarNearlyZero &&
-                     fPoints[i].fY - fBounds.fBottom < SK_ScalarNearlyZero));
+                     fBounds->fLeft - fPoints[i].fX   < SK_ScalarNearlyZero &&
+                     fPoints[i].fX - fBounds->fRight  < SK_ScalarNearlyZero &&
+                     fBounds->fTop  - fPoints[i].fY   < SK_ScalarNearlyZero &&
+                     fPoints[i].fY - fBounds->fBottom < SK_ScalarNearlyZero));
             if (!fPoints[i].isFinite()) {
                 isFinite = false;
             }
         }
         SkASSERT(SkToBool(fIsFinite) == isFinite);
     }
 
 #ifdef SK_DEBUG_PATH
     uint32_t mask = 0;
     for (int i = 0; i < fVerbCnt; ++i) {
@@ skipping 19 matching lines @@
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
                 break;
         }
     }
     SkASSERT(mask == fSegmentMask);
 #endif // SK_DEBUG_PATH
 }
 #endif