Make SkPath fFirstDirection atomic to fix tsan.

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 18 matching lines @@
 
 static bool is_degenerate(const SkPath& path) {
     SkPath::Iter iter(path, false);
     SkPoint pts[4];
     return SkPath::kDone_Verb == iter.next(pts);
 }
 
 class SkAutoDisableDirectionCheck {
 public:
     SkAutoDisableDirectionCheck(SkPath* path) : fPath(path) {
-        fSaved = static_cast<SkPathPriv::FirstDirection>(fPath->fFirstDirection);
+        fSaved = static_cast<SkPathPriv::FirstDirection>(fPath->fFirstDirection.load());
     }
 
     ~SkAutoDisableDirectionCheck() {
         fPath->fFirstDirection = fSaved;
     }
 
 private:
     SkPath*                     fPath;
     SkPathPriv::FirstDirection  fSaved;
 };
@@ skipping 109 matching lines @@
     }
     SkDEBUGCODE(this->validate();)
     return *this;
 }
 
 void SkPath::copyFields(const SkPath& that) {
     //fPathRef is assumed to have been set by the caller.
     fLastMoveToIndex = that.fLastMoveToIndex;
     fFillType        = that.fFillType;
     fConvexity       = that.fConvexity;
-    fFirstDirection  = that.fFirstDirection;
+    // Simulate fFirstDirection  = that.fFirstDirection;
+    fFirstDirection.store(that.fFirstDirection.load());
     fIsVolatile      = that.fIsVolatile;
 }
 
 bool operator==(const SkPath& a, const SkPath& b) {
     // note: don't need to look at isConvex or bounds, since just comparing the
     // raw data is sufficient.
     return &a == &b ||
         (a.fFillType == b.fFillType && *a.fPathRef.get() == *b.fPathRef.get());
 }
 
 void SkPath::swap(SkPath& that) {
     if (this != &that) {
         fPathRef.swap(&that.fPathRef);
         SkTSwap<int>(fLastMoveToIndex, that.fLastMoveToIndex);
         SkTSwap<uint8_t>(fFillType, that.fFillType);
         SkTSwap<uint8_t>(fConvexity, that.fConvexity);
-        SkTSwap<uint8_t>(fFirstDirection, that.fFirstDirection);
+        // Simulate SkTSwap<uint8_t>(fFirstDirection, that.fFirstDirection);
+        uint8_t temp = fFirstDirection;
+        fFirstDirection.store(that.fFirstDirection.load());
+        that.fFirstDirection.store(temp);
         SkTSwap<SkBool8>(fIsVolatile, that.fIsVolatile);
     }
 }
 
 static inline bool check_edge_against_rect(const SkPoint& p0,
                                            const SkPoint& p1,
                                            const SkRect& rect,
                                            SkPathPriv::FirstDirection dir) {
     const SkPoint* edgeBegin;
     SkVector v;
@@ skipping 1291 matching lines @@
             dst->fIsVolatile = fIsVolatile;
         }
 
         if (SkPathPriv::kUnknown_FirstDirection == fFirstDirection) {
             dst->fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
         } else {
             SkScalar det2x2 =
                 SkScalarMul(matrix.get(SkMatrix::kMScaleX), matrix.get(SkMatrix::kMScaleY)) -
                 SkScalarMul(matrix.get(SkMatrix::kMSkewX), matrix.get(SkMatrix::kMSkewY));
             if (det2x2 < 0) {
-                dst->fFirstDirection = SkPathPriv::OppositeFirstDirection((SkPathPriv::FirstDirection)fFirstDirection);
+                dst->fFirstDirection = SkPathPriv::OppositeFirstDirection(
+                        (SkPathPriv::FirstDirection)fFirstDirection.load());
             } else if (det2x2 > 0) {
-                dst->fFirstDirection = fFirstDirection;
+                dst->fFirstDirection = fFirstDirection.load();
             } else {
                 dst->fConvexity = kUnknown_Convexity;
                 dst->fFirstDirection = SkPathPriv::kUnknown_FirstDirection;
             }
         }
 
         SkDEBUGCODE(dst->validate();)
     }
 }
 
@@ skipping 957 matching lines @@
 
 /*
  *  We loop through all contours, and keep the computed cross-product of the
  *  contour that contained the global y-max. If we just look at the first
  *  contour, we may find one that is wound the opposite way (correctly) since
  *  it is the interior of a hole (e.g. 'o'). Thus we must find the contour
  *  that is outer most (or at least has the global y-max) before we can consider
  *  its cross product.
  */
 bool SkPathPriv::CheapComputeFirstDirection(const SkPath& path, FirstDirection* dir) {
-    if (kUnknown_FirstDirection != path.fFirstDirection) {
-        *dir = static_cast<FirstDirection>(path.fFirstDirection);
+    if (kUnknown_FirstDirection != path.fFirstDirection.load()) {
+        *dir = static_cast<FirstDirection>(path.fFirstDirection.load());
         return true;
     }
 
     // don't want to pay the cost for computing this if it
     // is unknown, so we don't call isConvex()
     if (SkPath::kConvex_Convexity == path.getConvexityOrUnknown()) {
         SkASSERT(kUnknown_FirstDirection == path.fFirstDirection);
-        *dir = static_cast<FirstDirection>(path.fFirstDirection);
+        *dir = static_cast<FirstDirection>(path.fFirstDirection.load());
         return false;
     }
 
     ContourIter iter(*path.fPathRef.get());
 
     // initialize with our logical y-min
     SkScalar ymax = path.getBounds().fTop;
     SkScalar ymaxCross = 0;
 
     for (; !iter.done(); iter.next()) {
@@ skipping 310 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }